@redocly/openapi-core 1.0.0-beta.90 → 1.0.0-beta.93

package/__tests__/__snapshots__/bundle.test.ts.snap

@@ -144,10 +144,24 @@ paths:
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/vendor'
+                $ref: '#/components/schemas/vendor.schema'
 components:
   schemas:
     vendor:
+      $ref: '#/components/schemas/vendor.schema'
+    myvendor:
+      $ref: '#/components/schemas/vendor.schema'
+    simple:
+      type: string
+    A:
+      type: string
+    test:
+      $ref: '#/components/schemas/rename-2'
+    rename:
+      type: string
+    rename-2:
+      type: number
+    vendor.schema:
       title: vendor
       type: object
       description: Vendors
@@ -171,18 +185,6 @@ components:
           type: boolean
           description: One-time use
           default: false
-    myvendor:
-      $ref: '#/components/schemas/vendor'
-    simple:
-      type: string
-    A:
-      type: string
-    test:
-      $ref: '#/components/schemas/rename-2'
-    rename:
-      type: string
-    rename-2:
-      type: number
 
 `;
 

package/__tests__/ref-utils.test.ts

@@ -1,6 +1,6 @@
 import outdent from 'outdent';
 import { parseYamlToDocument } from './utils';
-import { parseRef } from '../src/ref-utils';
+import { parseRef, refBaseName } from '../src/ref-utils';
 import { lintDocument } from '../src/lint';
 import { LintConfig } from '../src/config/config';
 import { BaseResolver } from '../src/resolve';
@@ -95,4 +95,26 @@ describe('ref-utils', () => {
 
     expect(result).toMatchInlineSnapshot(`Array []`);
   });
+
+  describe('refBaseName', () => {
+    it("returns base name for file reference", () => {
+      expect(refBaseName("../testcase/Pet.yaml")).toStrictEqual("Pet");
+    });
+
+    it("returns base name for local file reference", () => {
+      expect(refBaseName("Cat.json")).toStrictEqual("Cat");
+    });
+
+    it("returns base name for url reference", () => {
+      expect(refBaseName("http://example.com/tests/crocodile.json")).toStrictEqual("crocodile");
+    });
+
+    it("returns base name for file with multiple dots in name", () => {
+      expect(refBaseName("feline.tiger.v1.yaml")).toStrictEqual("feline.tiger.v1");
+    });
+
+    it("returns base name for file without any dots in name", () => {
+      expect(refBaseName("abcdefg")).toStrictEqual("abcdefg");
+    });
+  });
 });

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;
@@ -444,17 +444,12 @@ function transformConfig(rawConfig) {
         throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
     }
     const _a = rawConfig, { apiDefinitions, referenceDocs } = _a, rest = __rest(_a, ["apiDefinitions", "referenceDocs"]);
-    // TODO: put links to the changelog and uncomment this after successful release of ReferenceDocs/Redoc, Portal and Workflows
-    // if (apiDefinitions) {
-    //   process.stderr.write(
-    //     `The ${yellow('apiDefinitions')} field is deprecated. Use ${green('apis')} instead, see changelog: <link>\n`
-    //   );
-    // }
-    // if (referenceDocs) {
-    //   process.stderr.write(
-    //     `The ${yellow('referenceDocs')} field is deprecated. Use ${green('features.openapi')} instead, see changelog: <link>\n`
-    //   );
-    // }
+    if (apiDefinitions) {
+        process.stderr.write(`The ${colorette_1.yellow('apiDefinitions')} field is deprecated. Use ${colorette_1.green('apis')} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`);
+    }
+    if (referenceDocs) {
+        process.stderr.write(`The ${colorette_1.yellow('referenceDocs')} field is deprecated. Use ${colorette_1.green('features.openapi')} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`);
+    }
     return Object.assign({ 'features.openapi': referenceDocs, apis: transformApiDefinitionsToApis(apiDefinitions) }, rest);
 }
 exports.transformConfig = transformConfig;

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/ref-utils.js

@@ -56,7 +56,7 @@ function pointerBaseName(pointer) {
 exports.pointerBaseName = pointerBaseName;
 function refBaseName(ref) {
     const parts = ref.split(/[\/\\]/); // split by '\' and '/'
-    return parts[parts.length - 1].split('.')[0];
+    return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
 }
 exports.refBaseName = refBaseName;
 function isAbsoluteUrl(ref) {

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/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.90",
+  "version": "1.0.0-beta.93",
   "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,
   );
 

package/src/config/all.ts

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