@redocly/openapi-core 1.0.0-beta.109 → 1.0.0-beta.110

package/README.md

@@ -10,7 +10,7 @@ See https://github.com/Redocly/redocly-cli
 import { formatProblems, lint, loadConfig } from '@redocly/openapi-core';
 
 const pathToApi = 'openapi.yaml';
-const config = loadConfig('optional/path/to/.redocly.yaml');
+const config = loadConfig({ configPath: 'optional/path/to/.redocly.yaml' });
 const lintResults = await lint({ ref: pathToApi, config });
 ```
 
@@ -20,6 +20,6 @@ const lintResults = await lint({ ref: pathToApi, config });
 import { formatProblems, bundle, loadConfig } from '@redocly/openapi-core';
 
 const pathToApi = 'openapi.yaml';
-const config = loadConfig('optional/path/to/.redocly.yaml');
+const config = loadConfig({ configPath: 'optional/path/to/.redocly.yaml' });
 const { bundle, problems } = await bundle({ ref: pathToApi, config });
 ```

package/lib/config/config-resolvers.js

@@ -30,6 +30,7 @@ const env_1 = require("../env");
 const utils_2 = require("../utils");
 const config_1 = require("./config");
 const logger_1 = require("../logger");
+const asserts_1 = require("../rules/common/assertions/asserts");
 function resolveConfig(rawConfig, configPath) {
     var _a, _b, _c, _d, _e;
     return __awaiter(this, void 0, void 0, function* () {
@@ -133,6 +134,9 @@ function resolvePlugins(plugins, configPath = '') {
                 plugin.decorators.oas2 = utils_1.prefixRules(pluginModule.decorators.oas2, id);
             }
         }
+        if (pluginModule.assertions) {
+            plugin.assertions = pluginModule.assertions;
+        }
         return plugin;
     })
         .filter(utils_2.isDefined);
@@ -196,8 +200,7 @@ function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configPath =
 function resolveStyleguideConfig(opts, parentConfigPaths = [], extendPaths = []) {
     return __awaiter(this, void 0, void 0, function* () {
         const resolvedStyleguideConfig = yield resolveAndMergeNestedStyleguideConfig(opts, parentConfigPaths, extendPaths);
-        return Object.assign(Object.assign({}, resolvedStyleguideConfig), { rules: resolvedStyleguideConfig.rules &&
-                groupStyleguideAssertionRules(resolvedStyleguideConfig.rules) });
+        return Object.assign(Object.assign({}, resolvedStyleguideConfig), { rules: resolvedStyleguideConfig.rules && groupStyleguideAssertionRules(resolvedStyleguideConfig) });
     });
 }
 exports.resolveStyleguideConfig = resolveStyleguideConfig;
@@ -238,7 +241,7 @@ function getMergedRawStyleguideConfig(rootStyleguideConfig, apiStyleguideConfig)
             : rootStyleguideConfig.recommendedFallback });
     return resultLint;
 }
-function groupStyleguideAssertionRules(rules) {
+function groupStyleguideAssertionRules({ rules, plugins, }) {
     if (!rules) {
         return rules;
     }
@@ -249,6 +252,21 @@ function groupStyleguideAssertionRules(rules) {
     for (const [ruleKey, rule] of Object.entries(rules)) {
         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]);
+                }
+            }
             assertions.push(Object.assign(Object.assign({}, assertion), { assertionId: ruleKey.replace('assert/', '') }));
         }
         else {

package/lib/config/config.d.ts

@@ -59,5 +59,6 @@ export declare class Config {
     'features.openapi': Record<string, any>;
     'features.mockServer'?: Record<string, any>;
     organization?: string;
+    files: string[];
     constructor(rawConfig: ResolvedConfig, configFile?: string | undefined);
 }

package/lib/config/config.js

@@ -249,6 +249,7 @@ class Config {
         this.resolve = utils_2.getResolveConfig(rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.resolve);
         this.region = rawConfig.region;
         this.organization = rawConfig.organization;
+        this.files = rawConfig.files || [];
     }
 }
 exports.Config = Config;

package/lib/config/load.d.ts

@@ -1,7 +1,13 @@
 import { Config } from './config';
-import type { RawConfig } from './types';
+import type { RawConfig, Region } from './types';
 import { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
-export declare function loadConfig(configPath?: string | undefined, customExtends?: string[], processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>): Promise<Config>;
+export declare function loadConfig(options?: {
+    configPath?: string;
+    customExtends?: string[];
+    processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>;
+    files?: string[];
+    region?: Region;
+}): 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>;

package/lib/config/load.js

@@ -59,9 +59,11 @@ function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, }) {
         return config_resolvers_1.resolveConfig(rawConfig, configPath);
     });
 }
-function loadConfig(configPath = findConfig(), customExtends, processRawConfig) {
+function loadConfig(options = {}) {
     return __awaiter(this, void 0, void 0, function* () {
-        const rawConfig = yield getConfig(configPath);
+        const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
+        const config = yield getConfig(configPath);
+        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);
         }

package/lib/config/types.d.ts

@@ -1,6 +1,7 @@
 import type { ProblemSeverity } from '../walk';
 import type { Oas3PreprocessorsSet, OasMajorVersion, Oas3DecoratorsSet, Oas2RuleSet, Oas2PreprocessorsSet, Oas2DecoratorsSet, Oas3RuleSet, OasVersion } from '../oas-types';
 import type { NodeType } from '../types';
+import { Location } from '../ref-utils';
 export declare type RuleSeverity = ProblemSeverity | 'off';
 export declare type PreprocessorSeverity = RuleSeverity | 'on';
 export declare type RuleConfig = RuleSeverity | ({
@@ -50,6 +51,12 @@ export declare type CustomRulesConfig = {
     oas3?: Oas3RuleSet;
     oas2?: Oas2RuleSet;
 };
+export declare type AssertResult = {
+    message?: string;
+    location?: Location;
+};
+export declare type CustomFunction = (value: any, options: unknown, baseLocation: Location) => AssertResult[];
+export declare type AssertionsConfig = Record<string, CustomFunction>;
 export declare type Plugin = {
     id: string;
     configs?: Record<string, PluginStyleguideConfig>;
@@ -57,6 +64,7 @@ export declare type Plugin = {
     preprocessors?: PreprocessorsConfig;
     decorators?: DecoratorsConfig;
     typeExtension?: TypeExtensionsConfig;
+    assertions?: AssertionsConfig;
 };
 export declare type PluginStyleguideConfig = Omit<StyleguideRawConfig, 'plugins' | 'extends'>;
 export declare type ResolveHeader = {
@@ -101,6 +109,7 @@ export declare type DeprecatedInApi = {
 };
 export declare type ResolvedApi = Omit<Api, 'styleguide'> & {
     styleguide: ResolvedStyleguideConfig;
+    files?: string[];
 };
 export declare type RawConfig = {
     apis?: Record<string, Api>;
@@ -108,6 +117,7 @@ export declare type RawConfig = {
     resolve?: RawResolveConfig;
     region?: Region;
     organization?: string;
+    files?: string[];
 } & FeaturesConfig;
 export declare type FlatApi = Omit<Api, 'styleguide'> & Omit<ApiStyleguideRawConfig, 'doNotResolveExamples'>;
 export declare type FlatRawConfig = Omit<RawConfig, 'styleguide' | 'resolve' | 'apis'> & Omit<StyleguideRawConfig, 'doNotResolveExamples'> & {

package/lib/config/utils.js

@@ -139,7 +139,7 @@ function mergeExtends(rulesConfList) {
 }
 exports.mergeExtends = mergeExtends;
 function getMergedConfig(config, apiName) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const extendPaths = [
         ...Object.values(config.apis).map((api) => { var _a; return (_a = api === null || api === void 0 ? void 0 : api.styleguide) === null || _a === void 0 ? void 0 : _a.extendPaths; }),
         (_b = (_a = config.rawConfig) === null || _a === void 0 ? void 0 : _a.styleguide) === null || _b === void 0 ? void 0 : _b.extendPaths,
@@ -156,7 +156,7 @@ function getMergedConfig(config, apiName) {
         ? new config_1.Config(Object.assign(Object.assign({}, config.rawConfig), { styleguide: Object.assign(Object.assign({}, (config.apis[apiName]
                 ? config.apis[apiName].styleguide
                 : config.rawConfig.styleguide)), { extendPaths,
-                pluginPaths }), 'features.openapi': Object.assign(Object.assign({}, config['features.openapi']), (_e = config.apis[apiName]) === null || _e === void 0 ? void 0 : _e['features.openapi']), 'features.mockServer': Object.assign(Object.assign({}, config['features.mockServer']), (_f = config.apis[apiName]) === null || _f === void 0 ? void 0 : _f['features.mockServer']) }), config.configFile)
+                pluginPaths }), 'features.openapi': Object.assign(Object.assign({}, config['features.openapi']), (_e = config.apis[apiName]) === null || _e === void 0 ? void 0 : _e['features.openapi']), 'features.mockServer': Object.assign(Object.assign({}, config['features.mockServer']), (_f = config.apis[apiName]) === null || _f === void 0 ? void 0 : _f['features.mockServer']), files: [...config.files, ...((_j = (_h = (_g = config.apis) === null || _g === void 0 ? void 0 : _g[apiName]) === null || _h === void 0 ? void 0 : _h.files) !== null && _j !== void 0 ? _j : [])] }), config.configFile)
         : config;
 }
 exports.getMergedConfig = getMergedConfig;

package/lib/rules/ajv.d.ts

@@ -1,4 +1,4 @@
-import { ErrorObject } from '@redocly/ajv';
+import { ErrorObject } from '@redocly/ajv/dist/2020';
 import { Location } from '../ref-utils';
 import { ResolveFn } from '../walk';
 export declare function releaseAjvInstance(): void;

package/lib/rules/ajv.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateJsonSchema = exports.releaseAjvInstance = void 0;
-const ajv_1 = require("@redocly/ajv");
+const _2020_1 = require("@redocly/ajv/dist/2020");
 const ref_utils_1 = require("../ref-utils");
 let ajvInstance = null;
 function releaseAjvInstance() {
@@ -10,7 +10,7 @@ function releaseAjvInstance() {
 exports.releaseAjvInstance = releaseAjvInstance;
 function getAjv(resolve, allowAdditionalProperties) {
     if (!ajvInstance) {
-        ajvInstance = new ajv_1.default({
+        ajvInstance = new _2020_1.default({
             schemaId: '$id',
             meta: true,
             allErrors: true,
@@ -20,7 +20,7 @@ function getAjv(resolve, allowAdditionalProperties) {
             discriminator: true,
             allowUnionTypes: true,
             validateFormats: false,
-            defaultAdditionalProperties: allowAdditionalProperties,
+            defaultUnevaluatedProperties: allowAdditionalProperties,
             loadSchemaSync(base, $ref) {
                 const resolvedRef = resolve({ $ref }, base.split('#')[0]);
                 if (!resolvedRef || !resolvedRef.location)
@@ -68,8 +68,8 @@ function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allo
         if (propName) {
             message = `\`${propName}\` property ${message}`;
         }
-        if (error.keyword === 'additionalProperties') {
-            const property = error.params.additionalProperty;
+        if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
+            const property = error.params.additionalProperty || error.params.unevaluatedProperty;
             message = `${message} \`${property}\``;
             error.instancePath += '/' + ref_utils_1.escapePointer(property);
         }

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

@@ -1,10 +1,8 @@
+import { AssertResult, CustomFunction } from 'core/src/config/types';
 import { Location } from '../../../ref-utils';
-declare type AssertResult = {
-    isValid: boolean;
-    location?: Location;
-};
-declare type Asserts = Record<string, (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult>;
+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 const asserts: Asserts;
+export declare function buildAssertCustomFunction(fn: CustomFunction): (value: string[], options: any, baseLocation: Location) => any;
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
+exports.buildAssertCustomFunction = exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
 const utils_1 = require("../../../utils");
 const utils_2 = require("./utils");
 exports.runOnKeysSet = new Set([
@@ -32,145 +32,185 @@ exports.runOnValuesSet = new Set([
 exports.asserts = {
     pattern: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+            return []; // property doesn't exist, no need to lint it with this assert
         const values = utils_1.isString(value) ? [value] : value;
         const regx = utils_2.regexFromString(condition);
-        for (const _val of values) {
-            if (!(regx === null || regx === void 0 ? void 0 : regx.test(_val))) {
-                return { isValid: false, location: utils_1.isString(value) ? baseLocation : baseLocation.key() };
-            }
-        }
-        return { isValid: true };
+        return values
+            .map((_val) => !(regx === null || regx === void 0 ? void 0 : regx.test(_val)) && {
+            message: `"${_val}" should match a regex ${condition}`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
     },
     enum: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+            return []; // property doesn't exist, no need to lint it with this assert
         const values = utils_1.isString(value) ? [value] : value;
-        for (const _val of values) {
-            if (!condition.includes(_val)) {
-                return {
-                    isValid: false,
-                    location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
-                };
-            }
-        }
-        return { isValid: true };
+        return values
+            .map((_val) => !condition.includes(_val) && {
+            message: `"${_val}" should be one of the predefined values`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
     },
     defined: (value, condition = true, baseLocation) => {
         const isDefined = typeof value !== 'undefined';
-        return { isValid: condition ? isDefined : !isDefined, location: baseLocation };
+        const isValid = condition ? isDefined : !isDefined;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should be defined` : 'Should be not defined',
+                    location: baseLocation,
+                },
+            ];
     },
     required: (value, keys, baseLocation) => {
-        for (const requiredKey of keys) {
-            if (!value.includes(requiredKey)) {
-                return { isValid: false, location: baseLocation.key() };
-            }
-        }
-        return { isValid: true };
+        return keys
+            .map((requiredKey) => !value.includes(requiredKey) && {
+            message: `${requiredKey} is required`,
+            location: baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
     },
     disallowed: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+            return []; // property doesn't exist, no need to lint it with this assert
         const values = utils_1.isString(value) ? [value] : value;
-        for (const _val of values) {
-            if (condition.includes(_val)) {
-                return {
-                    isValid: false,
-                    location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
-                };
-            }
-        }
-        return { isValid: true };
+        return values
+            .map((_val) => condition.includes(_val) && {
+            message: `"${_val}" is disallowed`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
     },
     undefined: (value, condition = true, baseLocation) => {
         const isUndefined = typeof value === 'undefined';
-        return { isValid: condition ? isUndefined : !isUndefined, location: baseLocation };
+        const isValid = condition ? isUndefined : !isUndefined;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be defined` : 'Should be defined',
+                    location: baseLocation,
+                },
+            ];
     },
     nonEmpty: (value, condition = true, baseLocation) => {
         const isEmpty = typeof value === 'undefined' || value === null || value === '';
-        return { isValid: condition ? !isEmpty : isEmpty, location: baseLocation };
+        const isValid = condition ? !isEmpty : isEmpty;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be empty` : 'Should be empty',
+                    location: baseLocation,
+                },
+            ];
     },
     minLength: (value, condition, baseLocation) => {
-        if (typeof value === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
-        return { isValid: value.length >= condition, location: baseLocation };
+        if (typeof value === 'undefined' || value.length >= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [{ message: `Should have at least ${condition} characters`, location: baseLocation }];
     },
     maxLength: (value, condition, baseLocation) => {
-        if (typeof value === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
-        return { isValid: value.length <= condition, location: baseLocation };
+        if (typeof value === 'undefined' || value.length <= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [{ message: `Should have at most ${condition} characters`, location: baseLocation }];
     },
     casing: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+            return []; // property doesn't exist, no need to lint it with this assert
         const values = utils_1.isString(value) ? [value] : value;
-        for (const _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 {
-                    isValid: false,
-                    location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
-                };
-            }
-        }
-        return { isValid: true };
+        const casingRegexes = {
+            camelCase: /^[a-z][a-zA-Z0-9]+$/g,
+            'kebab-case': /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g,
+            snake_case: /^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g,
+            PascalCase: /^[A-Z][a-zA-Z0-9]+$/g,
+            MACRO_CASE: /^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g,
+            'COBOL-CASE': /^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g,
+            flatcase: /^[a-z][a-z0-9]+$/g,
+        };
+        return values
+            .map((_val) => !_val.match(casingRegexes[condition]) && {
+            message: `"${_val}" should use ${condition}`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
     },
     sortOrder: (value, condition, baseLocation) => {
-        if (typeof value === 'undefined')
-            return { isValid: true };
-        return { isValid: utils_2.isOrdered(value, condition), location: baseLocation };
+        if (typeof value === 'undefined' || utils_2.isOrdered(value, condition))
+            return [];
+        const direction = condition.direction || condition;
+        const property = condition.property;
+        return [
+            {
+                message: `Should be sorted in ${direction === 'asc' ? 'an ascending' : 'a descending'} order${property ? ` by property ${property}` : ''}`,
+                location: baseLocation,
+            },
+        ];
     },
     mutuallyExclusive: (value, condition, baseLocation) => {
-        return { isValid: utils_2.getIntersectionLength(value, condition) < 2, location: baseLocation.key() };
+        if (utils_2.getIntersectionLength(value, condition) < 2)
+            return [];
+        return [
+            {
+                message: `${condition.join(', ')} keys should be mutually exclusive`,
+                location: baseLocation.key(),
+            },
+        ];
     },
     mutuallyRequired: (value, condition, baseLocation) => {
-        return {
-            isValid: utils_2.getIntersectionLength(value, condition) > 0
-                ? utils_2.getIntersectionLength(value, condition) === condition.length
-                : true,
-            location: baseLocation.key(),
-        };
+        const isValid = utils_2.getIntersectionLength(value, condition) > 0
+            ? utils_2.getIntersectionLength(value, condition) === condition.length
+            : true;
+        return isValid
+            ? []
+            : [
+                {
+                    message: `Properties ${condition.join(', ')} are mutually required`,
+                    location: baseLocation.key(),
+                },
+            ];
     },
     requireAny: (value, condition, baseLocation) => {
-        return { isValid: utils_2.getIntersectionLength(value, condition) >= 1, location: baseLocation.key() };
+        return utils_2.getIntersectionLength(value, condition) >= 1
+            ? []
+            : [
+                {
+                    message: `Should have any of ${condition.join(', ')}`,
+                    location: baseLocation.key(),
+                },
+            ];
     },
     ref: (_value, condition, baseLocation, rawValue) => {
         if (typeof rawValue === 'undefined')
-            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+            return []; // property doesn't exist, no need to lint it with this assert
         const hasRef = rawValue.hasOwnProperty('$ref');
         if (typeof condition === 'boolean') {
-            return {
-                isValid: condition ? hasRef : !hasRef,
-                location: hasRef ? baseLocation : baseLocation.key(),
-            };
+            const isValid = condition ? hasRef : !hasRef;
+            return isValid
+                ? []
+                : [
+                    {
+                        message: condition ? `should use $ref` : 'should not use $ref',
+                        location: hasRef ? baseLocation : baseLocation.key(),
+                    },
+                ];
         }
         const regex = utils_2.regexFromString(condition);
-        return {
-            isValid: hasRef && (regex === null || regex === void 0 ? void 0 : regex.test(rawValue['$ref'])),
-            location: hasRef ? baseLocation : baseLocation.key(),
-        };
+        const isValid = hasRef && (regex === null || regex === void 0 ? void 0 : regex.test(rawValue['$ref']));
+        return isValid
+            ? []
+            : [
+                {
+                    message: `$ref value should match ${condition}`,
+                    location: hasRef ? baseLocation : baseLocation.key(),
+                },
+            ];
     },
 };
+function buildAssertCustomFunction(fn) {
+    return (value, options, baseLocation) => fn.call(null, value, options, baseLocation);
+}
+exports.buildAssertCustomFunction = buildAssertCustomFunction;

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

@@ -7,7 +7,7 @@ const Assertions = (opts) => {
     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);
@@ -23,12 +23,8 @@ const Assertions = (opts) => {
             .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),
             };
@@ -42,7 +38,7 @@ const Assertions = (opts) => {
             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 subjectVisitor = utils_1.buildSubjectVisitor(assertId, assertion, assertsToApply);
             const visitorObject = utils_1.buildVisitorObject(subject, assertion.context, subjectVisitor);
             visitors.push(visitorObject);
         }

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

@@ -1,21 +1,27 @@
-import { ProblemSeverity, UserContext } from '../../../walk';
+import type { RuleSeverity } from '../../../config';
+import { UserContext } from '../../../walk';
 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;
-    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, rawLocation, key, type, resolve, rawNode }: UserContext) => void;
+export declare function buildSubjectVisitor(assertId: string, assertion: Assertion, asserts: AssertToApply[]): (node: any, { report, location, rawLocation, key, type, resolve, rawNode }: UserContext) => void;
 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 {};