@redocly/openapi-core 1.0.0-beta.91 → 1.0.0-beta.94

package/__tests__/normalizeVisitors.test.ts

@@ -112,7 +112,7 @@ describe('Normalize visitors', () => {
     expect(normalized.PathItem.enter).toHaveLength(1);
     expect(normalized.Operation.enter).toHaveLength(1);
     expect(normalized.Parameter.enter).toHaveLength(1);
-    expect(normalized.Parameter_List.enter).toHaveLength(2);
+    expect(normalized.ParameterList.enter).toHaveLength(2);
   });
 
   it('should order deeper visitors first', () => {

package/__tests__/walk.test.ts

@@ -1057,12 +1057,12 @@ describe('walk order', () => {
         "enter DefinitionRoot",
         "enter PathMap",
         "enter PathItem",
-        "enter Parameter_List",
+        "enter ParameterList",
         "enter Parameter",
         "leave Parameter",
-        "leave Parameter_List",
+        "leave ParameterList",
         "enter Operation",
-        "enter Parameter_List",
+        "enter ParameterList",
         "enter ref #/components/parameters/shared_a",
         "enter Parameter",
         "leave Parameter",
@@ -1071,7 +1071,7 @@ describe('walk order', () => {
         "leave Parameter",
         "enter Parameter",
         "leave Parameter",
-        "leave Parameter_List",
+        "leave ParameterList",
         "leave Operation",
         "leave PathItem",
         "leave PathMap",
@@ -1404,10 +1404,10 @@ describe('type extensions', () => {
         "enter DefinitionRoot",
         "enter XWebHooks",
         "enter hook test",
-        "enter Parameter_List",
+        "enter ParameterList",
         "enter Parameter",
         "leave Parameter",
-        "leave Parameter_List",
+        "leave ParameterList",
         "leave hook test",
         "leave XWebHooks",
         "leave DefinitionRoot",

package/lib/config/all.js

@@ -19,6 +19,7 @@ exports.default = {
         'operation-description': 'error',
         'operation-2xx-response': 'error',
         'operation-4xx-response': 'error',
+        'assertions': 'error',
         'operation-operationId': 'error',
         'operation-summary': 'error',
         'operation-operationId-unique': 'error',

package/lib/config/config.js

@@ -417,7 +417,7 @@ function assignExisting(target, obj) {
 function getMergedConfig(config, entrypointAlias) {
     var _a, _b;
     return entrypointAlias
-        ? new Config(Object.assign(Object.assign({}, config.rawConfig), { lint: getMergedLintConfig(config, entrypointAlias), 'features.openapi': Object.assign(Object.assign({}, config['features.openapi']), (_a = config.apis[entrypointAlias]) === null || _a === void 0 ? void 0 : _a['features.openapi']), 'features.mockServer': Object.assign(Object.assign({}, config['features.mockServer']), (_b = config.apis[entrypointAlias]) === null || _b === void 0 ? void 0 : _b['features.mockServer']) }))
+        ? new Config(Object.assign(Object.assign({}, config.rawConfig), { lint: getMergedLintConfig(config, entrypointAlias), 'features.openapi': Object.assign(Object.assign({}, config['features.openapi']), (_a = config.apis[entrypointAlias]) === null || _a === void 0 ? void 0 : _a['features.openapi']), 'features.mockServer': Object.assign(Object.assign({}, config['features.mockServer']), (_b = config.apis[entrypointAlias]) === null || _b === void 0 ? void 0 : _b['features.mockServer']) }), config.configFile)
         : config;
 }
 exports.getMergedConfig = getMergedConfig;

package/lib/config/minimal.js

@@ -18,6 +18,7 @@ exports.default = {
         'operation-description': 'off',
         'operation-2xx-response': 'warn',
         'operation-4xx-response': 'off',
+        'assertions': 'warn',
         'operation-operationId': 'warn',
         'operation-summary': 'warn',
         'operation-operationId-unique': 'warn',

package/lib/config/recommended.js

@@ -17,6 +17,7 @@ exports.default = {
         'path-parameters-defined': 'error',
         'operation-description': 'off',
         'operation-2xx-response': 'warn',
+        'assertions': 'warn',
         'operation-4xx-response': 'warn',
         'operation-operationId': 'warn',
         'operation-summary': 'error',

package/lib/config/rules.d.ts

@@ -1,7 +1,7 @@
 import { RuleSet, OasVersion } from '../oas-types';
 import { LintConfig } from './config';
 export declare function initRules<T extends Function, P extends RuleSet<T>>(rules: P[], config: LintConfig, type: 'rules' | 'preprocessors' | 'decorators', oasVersion: OasVersion): {
-    severity: import("..").ProblemSeverity;
+    severity: import("..").ProblemSeverity | "off";
     ruleId: string;
     visitor: any;
 }[];

package/lib/config/rules.js

@@ -14,13 +14,21 @@ function initRules(rules, config, type, oasVersion) {
         if (ruleSettings.severity === 'off') {
             return undefined;
         }
-        const visitor = rule(ruleSettings);
+        const visitors = rule(ruleSettings);
+        if (Array.isArray(visitors)) {
+            return visitors.map((visitor) => ({
+                severity: ruleSettings.severity,
+                ruleId,
+                visitor: visitor,
+            }));
+        }
         return {
             severity: ruleSettings.severity,
             ruleId,
-            visitor,
+            visitor: visitors, // note: actually it is only one visitor object
         };
     }))
+        .flatMap(visitor => visitor)
         .filter(utils_1.notUndefined);
 }
 exports.initRules = initRules;

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

@@ -0,0 +1,5 @@
+declare type Asserts = Record<string, (value: any, condition: any) => boolean>;
+export declare const runOnKeysSet: Set<string>;
+export declare const runOnValuesSet: Set<string>;
+export declare const asserts: Asserts;
+export {};

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
+const utils_1 = require("./utils");
+exports.runOnKeysSet = new Set([
+    'mutuallyExclusive',
+    'mutuallyRequired',
+    'enum',
+    'pattern',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+    'disallowed',
+    'required',
+]);
+exports.runOnValuesSet = new Set([
+    'pattern',
+    'enum',
+    'defined',
+    'undefined',
+    'nonEmpty',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+]);
+exports.asserts = {
+    pattern: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        const regexOptions = condition.match(/(\b\/\b)(.+)/g) || ['/'];
+        condition = condition.slice(1).replace(regexOptions[0], '');
+        const regx = new RegExp(condition, regexOptions[0].slice(1));
+        for (let _val of values) {
+            if (!_val.match(regx)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    enum: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        for (let _val of values) {
+            if (!condition.includes(_val)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    defined: (value, condition = true) => {
+        const isDefined = typeof value !== 'undefined';
+        return condition ? isDefined : !isDefined;
+    },
+    required: (value, keys) => {
+        for (const requiredKey of keys) {
+            if (!value.includes(requiredKey)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    disallowed: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        for (let _val of values) {
+            if (condition.includes(_val)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    undefined: (value, condition = true) => {
+        const isUndefined = typeof value === 'undefined';
+        return condition ? isUndefined : !isUndefined;
+    },
+    nonEmpty: (value, condition = true) => {
+        const isEmpty = typeof value === 'undefined' || value === null || value === '';
+        return condition ? !isEmpty : isEmpty;
+    },
+    minLength: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        return value.length >= condition;
+    },
+    maxLength: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        return value.length <= condition;
+    },
+    casing: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        for (let _val of values) {
+            let matchCase = false;
+            switch (condition) {
+                case 'camelCase':
+                    matchCase = !!_val.match(/^[a-z][a-zA-Z0-9]+$/g);
+                    break;
+                case 'kebab-case':
+                    matchCase = !!_val.match(/^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g);
+                    break;
+                case 'snake_case':
+                    matchCase = !!_val.match(/^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g);
+                    break;
+                case 'PascalCase':
+                    matchCase = !!_val.match(/^[A-Z][a-zA-Z0-9]+$/g);
+                    break;
+                case 'MACRO_CASE':
+                    matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g);
+                    break;
+                case 'COBOL-CASE':
+                    matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g);
+                    break;
+                case 'flatcase':
+                    matchCase = !!_val.match(/^[a-z][a-z0-9]+$/g);
+                    break;
+            }
+            if (!matchCase) {
+                return false;
+            }
+        }
+        return true;
+    },
+    sortOrder: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true;
+        return utils_1.isOrdered(value, condition);
+    },
+    mutuallyExclusive: (value, condition) => {
+        return utils_1.getIntersectionLength(value, condition) < 2;
+    },
+    mutuallyRequired: (value, condition) => {
+        return utils_1.getIntersectionLength(value, condition) > 0
+            ? utils_1.getIntersectionLength(value, condition) === condition.length
+            : true;
+    },
+};

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

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

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assertions = void 0;
+const asserts_1 = require("./asserts");
+const utils_1 = require("./utils");
+const Assertions = (opts) => {
+    let visitors = [];
+    // As 'Assertions' has an array of asserts,
+    // that array spreads into an 'opts' object on init rules phase here
+    // https://github.com/Redocly/openapi-cli/blob/master/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);
+        }
+    }
+    return visitors;
+};
+exports.Assertions = Assertions;

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

@@ -0,0 +1,20 @@
+import { ProblemSeverity, UserContext } from '../../../walk';
+export declare type OrderDirection = 'asc' | 'desc';
+export declare type OrderOptions = {
+    direction: OrderDirection;
+    property: string;
+};
+export declare type AssertToApply = {
+    name: string;
+    assertId?: string;
+    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 }: UserContext) => void;
+export declare function getIntersectionLength(keys: string[], properties: string[]): number;
+export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
+const asserts_1 = require("./asserts");
+function buildVisitorObject(subject, context, subjectVisitor) {
+    if (!context) {
+        return { [subject]: subjectVisitor };
+    }
+    let currentVisitorLevel = {};
+    const visitor = currentVisitorLevel;
+    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`);
+        }
+        if (matchParentKeys || excludeParentKeys) {
+            currentVisitorLevel[node.type] = {
+                skip: (_value, key) => {
+                    if (matchParentKeys) {
+                        return !matchParentKeys.includes(key);
+                    }
+                    if (excludeParentKeys) {
+                        return excludeParentKeys.includes(key);
+                    }
+                },
+            };
+        }
+        else {
+            currentVisitorLevel[node.type] = {};
+        }
+        currentVisitorLevel = currentVisitorLevel[node.type];
+    }
+    currentVisitorLevel[subject] = subjectVisitor;
+    return visitor;
+}
+exports.buildVisitorObject = buildVisitorObject;
+function buildSubjectVisitor(properties, asserts, context) {
+    return function (node, { report, location, key, type }) {
+        // 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) {
+                    runAssertion(node[property], assert, location.child(property), report);
+                }
+            }
+            else {
+                runAssertion(Object.keys(node), assert, location.key(), report);
+            }
+        }
+    };
+}
+exports.buildSubjectVisitor = buildSubjectVisitor;
+function getIntersectionLength(keys, properties) {
+    const props = new Set(properties);
+    let count = 0;
+    for (const key of keys) {
+        if (props.has(key)) {
+            count++;
+        }
+    }
+    return count;
+}
+exports.getIntersectionLength = getIntersectionLength;
+function isOrdered(value, options) {
+    const direction = options.direction || options;
+    const property = options.property;
+    for (let i = 1; i < value.length; i++) {
+        let currValue = value[i];
+        let prevVal = value[i - 1];
+        if (property) {
+            if (!value[i][property] || !value[i - 1][property]) {
+                return false; // property doesn't exist, so collection is not ordered
+            }
+            currValue = value[i][property];
+            prevVal = value[i - 1][property];
+        }
+        const result = direction === 'asc' ? currValue >= prevVal : currValue <= prevVal;
+        if (!result) {
+            return false;
+        }
+    }
+    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,
+        });
+    }
+}

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

@@ -15,6 +15,7 @@ export declare const rules: {
     'no-path-trailing-slash': Oas2Rule;
     'operation-2xx-response': Oas2Rule;
     'operation-4xx-response': Oas2Rule;
+    assertions: Oas2Rule;
     'operation-operationId-unique': Oas2Rule;
     'operation-parameters-unique': Oas2Rule;
     'path-parameters-defined': Oas2Rule;

package/lib/rules/oas2/index.js

@@ -16,6 +16,7 @@ const no_enum_type_mismatch_1 = require("../common/no-enum-type-mismatch");
 const no_path_trailing_slash_1 = require("../common/no-path-trailing-slash");
 const operation_2xx_response_1 = require("../common/operation-2xx-response");
 const operation_4xx_response_1 = require("../common/operation-4xx-response");
+const assertions_1 = require("../common/assertions");
 const operation_operationId_unique_1 = require("../common/operation-operationId-unique");
 const operation_parameters_unique_1 = require("../common/operation-parameters-unique");
 const path_params_defined_1 = require("../common/path-params-defined");
@@ -54,6 +55,7 @@ exports.rules = {
     'no-path-trailing-slash': no_path_trailing_slash_1.NoPathTrailingSlash,
     'operation-2xx-response': operation_2xx_response_1.Operation2xxResponse,
     'operation-4xx-response': operation_4xx_response_1.Operation4xxResponse,
+    'assertions': assertions_1.Assertions,
     'operation-operationId-unique': operation_operationId_unique_1.OperationIdUnique,
     'operation-parameters-unique': operation_parameters_unique_1.OperationParametersUnique,
     'path-parameters-defined': path_params_defined_1.PathParamsDefined,

package/lib/rules/oas3/index.js

@@ -4,6 +4,7 @@ exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
 const operation_2xx_response_1 = require("../common/operation-2xx-response");
 const operation_4xx_response_1 = require("../common/operation-4xx-response");
+const assertions_1 = require("../common/assertions");
 const operation_operationId_unique_1 = require("../common/operation-operationId-unique");
 const operation_parameters_unique_1 = require("../common/operation-parameters-unique");
 const path_params_defined_1 = require("../common/path-params-defined");
@@ -54,6 +55,7 @@ exports.rules = {
     'info-license-url': license_url_1.InfoLicenseUrl,
     'operation-2xx-response': operation_2xx_response_1.Operation2xxResponse,
     'operation-4xx-response': operation_4xx_response_1.Operation4xxResponse,
+    'assertions': assertions_1.Assertions,
     'operation-operationId-unique': operation_operationId_unique_1.OperationIdUnique,
     'operation-parameters-unique': operation_parameters_unique_1.OperationParametersUnique,
     'path-parameters-defined': path_params_defined_1.PathParamsDefined,

package/lib/types/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNamedType = exports.normalizeTypes = exports.mapOf = exports.listOf = void 0;
 function listOf(typeName) {
     return {
-        name: typeName + '_List',
+        name: `${typeName}List`,
         properties: {},
         items: typeName,
     };
@@ -11,7 +11,7 @@ function listOf(typeName) {
 exports.listOf = listOf;
 function mapOf(typeName) {
     return {
-        name: typeName + '_Map',
+        name: `${typeName}Map`,
         properties: {},
         additionalProperties: () => typeName,
     };

package/lib/types/oas3_1.js

@@ -17,7 +17,7 @@ const DefinitionRoot = {
         jsonSchemaDialect: { type: 'string' },
     },
     required: ['openapi', 'info'],
-    requiredOneOf: ['paths', 'components', 'webhooks']
+    requiredOneOf: ['paths', 'components', 'webhooks'],
 };
 const License = {
     properties: {
@@ -103,7 +103,10 @@ const Schema = {
         enum: { type: 'array' },
         type: (value) => {
             if (Array.isArray(value)) {
-                return { type: 'array', items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] } };
+                return {
+                    type: 'array',
+                    items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+                };
             }
             else {
                 return {
@@ -124,7 +127,14 @@ const Schema = {
         patternProperties: { type: 'object' },
         propertyNames: 'Schema',
         unevaluatedItems: 'Schema',
-        unevaluatedProperties: 'Schema',
+        unevaluatedProperties: (value) => {
+            if (typeof value === 'boolean') {
+                return { type: 'boolean' };
+            }
+            else {
+                return 'Schema';
+            }
+        },
         summary: { type: 'string' },
         properties: 'SchemaProperties',
         items: (value) => {
@@ -195,9 +205,25 @@ const SecurityScheme = {
                     case 'clientCredentials':
                         return ['type', 'flows', 'tokenUrl', 'refreshUrl', 'description', 'scopes'];
                     case 'authorizationCode':
-                        return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                        ];
                     default:
-                        return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                        ];
                 }
             case 'openIdConnect':
                 return ['type', 'openIdConnectUrl', 'description'];

package/lib/visitors.d.ts

@@ -156,8 +156,8 @@ export declare type NormalizedOasVisitors<T extends BaseVisitor> = {
         leave: Array<VisitorNode<any>>;
     };
 };
-export declare type Oas3Rule = (options: Record<string, any>) => Oas3Visitor;
-export declare type Oas2Rule = (options: Record<string, any>) => Oas2Visitor;
+export declare type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
+export declare type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
 export declare type Oas3Preprocessor = (options: Record<string, any>) => Oas3TransformVisitor;
 export declare type Oas2Preprocessor = (options: Record<string, any>) => Oas2TransformVisitor;
 export declare type Oas3Decorator = (options: Record<string, any>) => Oas3TransformVisitor;

package/lib/walk.d.ts

@@ -60,6 +60,7 @@ export declare type Problem = {
     location?: Partial<LocationObject> | Array<Partial<LocationObject>>;
     from?: LocationObject;
     forceSeverity?: ProblemSeverity;
+    ruleId?: string;
 };
 export declare type NormalizedProblem = {
     message: string;

package/lib/walk.js

@@ -240,7 +240,7 @@ function walkDocument(opts) {
                     ? opts.location
                     : [opts.location]
                 : [Object.assign(Object.assign({}, currentLocation), { reportOnKey: false })];
-            ctx.problems.push(Object.assign(Object.assign({ ruleId, severity: opts.forceSeverity || severity }, opts), { suggest: opts.suggest || [], location: loc.map((loc) => {
+            ctx.problems.push(Object.assign(Object.assign({ ruleId: opts.ruleId || ruleId, severity: opts.forceSeverity || severity }, opts), { suggest: opts.suggest || [], location: loc.map((loc) => {
                     return Object.assign(Object.assign(Object.assign({}, currentLocation), { reportOnKey: false }), loc);
                 }) }));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.91",
+  "version": "1.0.0-beta.94",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/bundle.ts

@@ -130,7 +130,7 @@ export async function bundleDocument(opts: {
         visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document, resolvedRefMap),
       },
       ...decorators,
-    ],
+    ] as any,
     types,
   );