@redocly/openapi-core 1.0.0-beta.100 → 1.0.0-beta.103

package/lib/config/config.d.ts

@@ -31,13 +31,13 @@ export declare class LintConfig {
     addProblemToIgnore(problem: NormalizedProblem): NormalizedProblem;
     extendTypes(types: Record<string, NodeType>, version: OasVersion): Record<string, NodeType>;
     getRuleSettings(ruleId: string, oasVersion: OasVersion): {
-        severity: import("../walk").ProblemSeverity | "off";
+        severity: import("./types").RuleSeverity;
     };
     getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): {
-        severity: import("../walk").ProblemSeverity | "off";
+        severity: import("./types").RuleSeverity;
     };
     getDecoratorSettings(ruleId: string, oasVersion: OasVersion): {
-        severity: import("../walk").ProblemSeverity | "off";
+        severity: import("./types").RuleSeverity;
     };
     getUnusedRules(): {
         rules: string[];

package/lib/config/load.d.ts

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

@@ -17,10 +17,9 @@ const utils_1 = require("../utils");
 const config_1 = require("./config");
 const utils_2 = require("./utils");
 const config_resolvers_1 = require("./config-resolvers");
-function loadConfig(configPath = findConfig(), customExtends) {
+function addConfigMetadata({ rawConfig, customExtends, configPath }) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        const rawConfig = yield getConfig(configPath);
         if (customExtends !== undefined) {
             rawConfig.lint = rawConfig.lint || {};
             rawConfig.lint.extends = customExtends;
@@ -61,7 +60,21 @@ function loadConfig(configPath = findConfig(), customExtends) {
         return config_resolvers_1.resolveConfig(rawConfig, configPath);
     });
 }
+function loadConfig(configPath = findConfig(), customExtends, processRawConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rawConfig = yield getConfig(configPath);
+        if (typeof processRawConfig === 'function') {
+            yield processRawConfig(rawConfig);
+        }
+        return yield addConfigMetadata({
+            rawConfig,
+            customExtends,
+            configPath,
+        });
+    });
+}
 exports.loadConfig = loadConfig;
+;
 exports.CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
 function findConfig(dir) {
     if (!fs.hasOwnProperty('existsSync'))

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 | "off";
+    severity: import("./types").RuleSeverity;
     ruleId: string;
     visitor: any;
 }[];

package/lib/config/types.d.ts

@@ -1,10 +1,12 @@
 import type { ProblemSeverity } from '../walk';
 import type { Oas3PreprocessorsSet, OasMajorVersion, Oas3DecoratorsSet, Oas2RuleSet, Oas2PreprocessorsSet, Oas2DecoratorsSet, Oas3RuleSet, OasVersion } from '../oas-types';
 import type { NodeType } from '../types';
-export declare type RuleConfig = ProblemSeverity | 'off' | ({
+export declare type RuleSeverity = ProblemSeverity | 'off';
+export declare type PreprocessorSeverity = RuleSeverity | 'on';
+export declare type RuleConfig = RuleSeverity | ({
     severity?: ProblemSeverity;
 } & Record<string, any>);
-export declare type PreprocessorConfig = ProblemSeverity | 'off' | 'on' | ({
+export declare type PreprocessorConfig = PreprocessorSeverity | ({
     severity?: ProblemSeverity;
 } & Record<string, any>);
 export declare type DecoratorConfig = PreprocessorConfig;

package/lib/decorators/common/filters/filter-helper.d.ts

@@ -0,0 +1,3 @@
+import { UserContext } from '../../../walk';
+export declare function filter(node: any, ctx: UserContext, criteria: (item: any) => boolean): void;
+export declare function checkIfMatchByStrategy(nodeValue: any, decoratorValue: any, strategy: 'all' | 'any'): boolean;

package/lib/decorators/common/filters/filter-helper.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfMatchByStrategy = exports.filter = void 0;
+const ref_utils_1 = require("../../../ref-utils");
+const utils_1 = require("../../../utils");
+function filter(node, ctx, criteria) {
+    const { parent, key } = ctx;
+    let didDelete = false;
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            if (ref_utils_1.isRef(node[i])) {
+                const resolved = ctx.resolve(node[i]);
+                if (criteria(resolved.node)) {
+                    node.splice(i, 1);
+                    didDelete = true;
+                    i--;
+                }
+            }
+            if (criteria(node[i])) {
+                node.splice(i, 1);
+                didDelete = true;
+                i--;
+            }
+        }
+    }
+    else if (utils_1.isPlainObject(node)) {
+        for (const key of Object.keys(node)) {
+            node = node;
+            if (ref_utils_1.isRef(node[key])) {
+                const resolved = ctx.resolve(node[key]);
+                if (criteria(resolved.node)) {
+                    delete node[key];
+                    didDelete = true;
+                }
+            }
+            if (criteria(node[key])) {
+                delete node[key];
+                didDelete = true;
+            }
+        }
+    }
+    if (didDelete && (utils_1.isEmptyObject(node) || utils_1.isEmptyArray(node))) {
+        delete parent[key];
+    }
+}
+exports.filter = filter;
+function checkIfMatchByStrategy(nodeValue, decoratorValue, strategy) {
+    if (!nodeValue || !decoratorValue) {
+        return false;
+    }
+    if (!Array.isArray(decoratorValue) && !Array.isArray(nodeValue)) {
+        return nodeValue === decoratorValue;
+    }
+    decoratorValue = toArrayIfNeeded(decoratorValue);
+    nodeValue = toArrayIfNeeded(nodeValue);
+    if (strategy === 'any') {
+        return decoratorValue.some((item) => nodeValue.includes(item));
+    }
+    if (strategy === 'all') {
+        return decoratorValue.every((item) => nodeValue.includes(item));
+    }
+    return false;
+}
+exports.checkIfMatchByStrategy = checkIfMatchByStrategy;
+function toArrayIfNeeded(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/lib/decorators/common/filters/filter-in.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Decorator, Oas3Decorator } from '../../../visitors';
+export declare const FilterIn: Oas3Decorator | Oas2Decorator;

package/lib/decorators/common/filters/filter-in.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterIn = void 0;
+const filter_helper_1 = require("./filter-helper");
+const DEFAULT_STRATEGY = 'any';
+const FilterIn = ({ property, value, matchStrategy }) => {
+    const strategy = matchStrategy || DEFAULT_STRATEGY;
+    const filterInCriteria = (item) => (item === null || item === void 0 ? void 0 : item[property]) && !filter_helper_1.checkIfMatchByStrategy(item === null || item === void 0 ? void 0 : item[property], value, strategy);
+    return {
+        any: {
+            enter: (node, ctx) => {
+                filter_helper_1.filter(node, ctx, filterInCriteria);
+            },
+        },
+    };
+};
+exports.FilterIn = FilterIn;

package/lib/decorators/common/filters/filter-out.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Decorator, Oas3Decorator } from '../../../visitors';
+export declare const FilterOut: Oas3Decorator | Oas2Decorator;

package/lib/decorators/common/filters/filter-out.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterOut = void 0;
+const filter_helper_1 = require("./filter-helper");
+const DEFAULT_STRATEGY = 'any';
+const FilterOut = ({ property, value, matchStrategy }) => {
+    const strategy = matchStrategy || DEFAULT_STRATEGY;
+    const filterOutCriteria = (item) => filter_helper_1.checkIfMatchByStrategy(item === null || item === void 0 ? void 0 : item[property], value, strategy);
+    return {
+        any: {
+            enter: (node, ctx) => {
+                filter_helper_1.filter(node, ctx, filterOutCriteria);
+            },
+        },
+    };
+};
+exports.FilterOut = FilterOut;

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

@@ -5,4 +5,6 @@ export declare const decorators: {
     'tag-description-override': Oas2Decorator;
     'info-description-override': Oas2Decorator;
     'remove-x-internal': Oas2Decorator;
+    'filter-in': Oas2Decorator;
+    'filter-out': Oas2Decorator;
 };

package/lib/decorators/oas2/index.js

@@ -6,10 +6,14 @@ const operation_description_override_1 = require("../common/operation-descriptio
 const tag_description_override_1 = require("../common/tag-description-override");
 const info_description_override_1 = require("../common/info-description-override");
 const remove_x_internal_1 = require("../common/remove-x-internal");
+const filter_in_1 = require("../common/filters/filter-in");
+const filter_out_1 = require("../common/filters/filter-out");
 exports.decorators = {
     'registry-dependencies': registry_dependencies_1.RegistryDependencies,
     'operation-description-override': operation_description_override_1.OperationDescriptionOverride,
     'tag-description-override': tag_description_override_1.TagDescriptionOverride,
     'info-description-override': info_description_override_1.InfoDescriptionOverride,
-    'remove-x-internal': remove_x_internal_1.RemoveXInternal
+    'remove-x-internal': remove_x_internal_1.RemoveXInternal,
+    'filter-in': filter_in_1.FilterIn,
+    'filter-out': filter_out_1.FilterOut,
 };

package/lib/decorators/oas3/index.d.ts

@@ -5,4 +5,6 @@ export declare const decorators: {
     'tag-description-override': Oas3Decorator;
     'info-description-override': Oas3Decorator;
     'remove-x-internal': Oas3Decorator;
+    'filter-in': Oas3Decorator;
+    'filter-out': Oas3Decorator;
 };

package/lib/decorators/oas3/index.js

@@ -6,10 +6,14 @@ const operation_description_override_1 = require("../common/operation-descriptio
 const tag_description_override_1 = require("../common/tag-description-override");
 const info_description_override_1 = require("../common/info-description-override");
 const remove_x_internal_1 = require("../common/remove-x-internal");
+const filter_in_1 = require("../common/filters/filter-in");
+const filter_out_1 = require("../common/filters/filter-out");
 exports.decorators = {
     'registry-dependencies': registry_dependencies_1.RegistryDependencies,
     'operation-description-override': operation_description_override_1.OperationDescriptionOverride,
     'tag-description-override': tag_description_override_1.TagDescriptionOverride,
     'info-description-override': info_description_override_1.InfoDescriptionOverride,
-    'remove-x-internal': remove_x_internal_1.RemoveXInternal
+    'remove-x-internal': remove_x_internal_1.RemoveXInternal,
+    'filter-in': filter_in_1.FilterIn,
+    'filter-out': filter_out_1.FilterOut,
 };

package/lib/index.d.ts

@@ -8,7 +8,7 @@ export { Oas2Definition } from './typings/swagger';
 export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
-export { Config, LintConfig, RawConfig, IGNORE_FILE, Region, getMergedConfig, transformConfig, loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES, } from './config';
+export { Config, LintConfig, RawConfig, IGNORE_FILE, Region, getMergedConfig, transformConfig, loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES, RuleSeverity } from './config';
 export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
 export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError, makeDocumentFromString, } from './resolve';
 export { parseYaml, stringifyYaml } from './js-yaml';

package/lib/lint.d.ts

@@ -1,5 +1,6 @@
 import { BaseResolver, Document } from './resolve';
 import { NodeType } from './types';
+import { ProblemSeverity } from './walk';
 import { LintConfig, Config } from './config';
 export declare function lint(opts: {
     ref: string;
@@ -20,4 +21,5 @@ export declare function lintDocument(opts: {
 }): Promise<import("./walk").NormalizedProblem[]>;
 export declare function lintConfig(opts: {
     document: Document;
+    severity?: ProblemSeverity;
 }): Promise<import("./walk").NormalizedProblem[]>;

package/lib/lint.js

@@ -72,7 +72,7 @@ function lintDocument(opts) {
 exports.lintDocument = lintDocument;
 function lintConfig(opts) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { document } = opts;
+        const { document, severity } = opts;
         const ctx = {
             problems: [],
             oasVersion: oas_types_1.OasVersion.Version3_0,
@@ -84,7 +84,7 @@ function lintConfig(opts) {
             rules: { spec: 'error' },
         });
         const types = types_1.normalizeTypes(redocly_yaml_1.ConfigTypes, config);
-        const rules = [{ severity: 'error', ruleId: 'spec', visitor: spec_1.OasSpec({ severity: 'error' }) }];
+        const rules = [{ severity: severity || 'error', ruleId: 'configuration spec', visitor: spec_1.OasSpec({ severity: 'error' }) }];
         const normalizedVisitors = visitors_1.normalizeVisitors(rules, types);
         walk_1.walkDocument({
             document,

package/lib/redocly/registry-api-types.d.ts

@@ -15,6 +15,8 @@ export declare namespace RegistryApiTypes {
         branch?: string;
         isUpsert?: boolean;
         isPublic?: boolean;
+        batchId?: string;
+        batchSize?: number;
     }
     export interface PrepareFileuploadOKResponse {
         filePath: string;

package/lib/redocly/registry-api.d.ts

@@ -13,5 +13,5 @@ export declare class RegistryApi {
         organizations: string[];
     }>;
     prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse>;
-    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }: RegistryApiTypes.PushApiParams): Promise<void>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize }: RegistryApiTypes.PushApiParams): Promise<void>;
 }

package/lib/redocly/registry-api.js

@@ -80,7 +80,7 @@ class RegistryApi {
             throw new Error('Could not prepare file upload');
         });
     }
-    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }) {
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.request(`/${organizationId}/${name}/${version}`, {
                 method: 'PUT',
@@ -94,6 +94,8 @@ class RegistryApi {
                     branch,
                     isUpsert,
                     isPublic,
+                    batchId,
+                    batchSize
                 }),
             }, this.region);
             if (response.ok) {

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

@@ -1,4 +1,9 @@
-declare type Asserts = Record<string, (value: any, condition: any) => boolean>;
+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>;
 export declare const runOnKeysSet: Set<string>;
 export declare const runOnValuesSet: Set<string>;
 export declare const asserts: Asserts;

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
-const utils_1 = require("./utils");
+const utils_1 = require("../../../utils");
+const utils_2 = require("./utils");
 exports.runOnKeysSet = new Set([
     'mutuallyExclusive',
     'mutuallyRequired',
@@ -13,6 +14,8 @@ exports.runOnKeysSet = new Set([
     'sortOrder',
     'disallowed',
     'required',
+    'requireAny',
+    'ref',
 ]);
 exports.runOnValuesSet = new Set([
     'pattern',
@@ -24,78 +27,83 @@ exports.runOnValuesSet = new Set([
     'maxLength',
     'casing',
     'sortOrder',
+    'ref',
 ]);
 exports.asserts = {
-    pattern: (value, condition) => {
+    pattern: (value, condition, baseLocation) => {
         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));
+            return { isValid: true }; // 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 (let _val of values) {
-            if (!_val.match(regx)) {
-                return false;
+            if (!(regx === null || regx === void 0 ? void 0 : regx.test(_val))) {
+                return { isValid: false, location: utils_1.isString(value) ? baseLocation : baseLocation.key() };
             }
         }
-        return true;
+        return { isValid: true };
     },
-    enum: (value, condition) => {
+    enum: (value, condition, baseLocation) => {
         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;
+            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+        const values = utils_1.isString(value) ? [value] : value;
         for (let _val of values) {
             if (!condition.includes(_val)) {
-                return false;
+                return {
+                    isValid: false,
+                    location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+                };
             }
         }
-        return true;
+        return { isValid: true };
     },
-    defined: (value, condition = true) => {
+    defined: (value, condition = true, baseLocation) => {
         const isDefined = typeof value !== 'undefined';
-        return condition ? isDefined : !isDefined;
+        return { isValid: condition ? isDefined : !isDefined, location: baseLocation };
     },
-    required: (value, keys) => {
+    required: (value, keys, baseLocation) => {
         for (const requiredKey of keys) {
             if (!value.includes(requiredKey)) {
-                return false;
+                return { isValid: false, location: baseLocation.key() };
             }
         }
-        return true;
+        return { isValid: true };
     },
-    disallowed: (value, condition) => {
+    disallowed: (value, condition, baseLocation) => {
         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;
+            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+        const values = utils_1.isString(value) ? [value] : value;
         for (let _val of values) {
             if (condition.includes(_val)) {
-                return false;
+                return {
+                    isValid: false,
+                    location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+                };
             }
         }
-        return true;
+        return { isValid: true };
     },
-    undefined: (value, condition = true) => {
+    undefined: (value, condition = true, baseLocation) => {
         const isUndefined = typeof value === 'undefined';
-        return condition ? isUndefined : !isUndefined;
+        return { isValid: condition ? isUndefined : !isUndefined, location: baseLocation };
     },
-    nonEmpty: (value, condition = true) => {
+    nonEmpty: (value, condition = true, baseLocation) => {
         const isEmpty = typeof value === 'undefined' || value === null || value === '';
-        return condition ? !isEmpty : isEmpty;
+        return { isValid: condition ? !isEmpty : isEmpty, location: baseLocation };
     },
-    minLength: (value, condition) => {
+    minLength: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        return value.length >= condition;
+            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+        return { isValid: value.length >= condition, location: baseLocation };
     },
-    maxLength: (value, condition) => {
+    maxLength: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        return value.length <= condition;
+            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+        return { isValid: value.length <= condition, location: baseLocation };
     },
-    casing: (value, condition) => {
+    casing: (value, condition, baseLocation) => {
         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;
+            return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+        const values = utils_1.isString(value) ? [value] : value;
         for (let _val of values) {
             let matchCase = false;
             switch (condition) {
@@ -122,22 +130,47 @@ exports.asserts = {
                     break;
             }
             if (!matchCase) {
-                return false;
+                return {
+                    isValid: false,
+                    location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+                };
             }
         }
-        return true;
+        return { isValid: true };
     },
-    sortOrder: (value, condition) => {
+    sortOrder: (value, condition, baseLocation) => {
         if (typeof value === 'undefined')
-            return true;
-        return utils_1.isOrdered(value, condition);
+            return { isValid: true };
+        return { isValid: utils_2.isOrdered(value, condition), location: baseLocation };
     },
-    mutuallyExclusive: (value, condition) => {
-        return utils_1.getIntersectionLength(value, condition) < 2;
+    mutuallyExclusive: (value, condition, baseLocation) => {
+        return { isValid: utils_2.getIntersectionLength(value, condition) < 2, location: baseLocation.key() };
     },
-    mutuallyRequired: (value, condition) => {
-        return utils_1.getIntersectionLength(value, condition) > 0
-            ? utils_1.getIntersectionLength(value, condition) === condition.length
-            : true;
+    mutuallyRequired: (value, condition, baseLocation) => {
+        return {
+            isValid: utils_2.getIntersectionLength(value, condition) > 0
+                ? utils_2.getIntersectionLength(value, condition) === condition.length
+                : true,
+            location: baseLocation.key(),
+        };
+    },
+    requireAny: (value, condition, baseLocation) => {
+        return { isValid: utils_2.getIntersectionLength(value, condition) >= 1, 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
+        const hasRef = rawValue.hasOwnProperty('$ref');
+        if (typeof condition === 'boolean') {
+            return {
+                isValid: condition ? hasRef : !hasRef,
+                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(),
+        };
     },
 };

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

@@ -15,6 +15,7 @@ export declare type AssertToApply = {
     runsOnValues: boolean;
 };
 export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
-export declare function buildSubjectVisitor(properties: string | string[], asserts: AssertToApply[], context?: Record<string, any>[]): (node: any, { report, location, key, type, resolve }: UserContext) => void;
+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 getIntersectionLength(keys: string[], properties: string[]): number;
 export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;
+export declare function regexFromString(input: string): RegExp | null;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
+exports.regexFromString = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
 const ref_utils_1 = require("../../../ref-utils");
 const asserts_1 = require("./asserts");
 function buildVisitorObject(subject, context, subjectVisitor) {
@@ -45,7 +45,7 @@ function buildVisitorObject(subject, context, subjectVisitor) {
 }
 exports.buildVisitorObject = buildVisitorObject;
 function buildSubjectVisitor(properties, asserts, context) {
-    return function (node, { report, location, key, type, resolve }) {
+    return (node, { report, location, rawLocation, key, type, resolve, rawNode }) => {
         var _a;
         // We need to check context's last node if it has the same type as subject node;
         // if yes - that means we didn't create context's last node visitor,
@@ -67,15 +67,29 @@ function buildSubjectVisitor(properties, asserts, context) {
             properties = Array.isArray(properties) ? properties : [properties];
         }
         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];
-                    runAssertion(value, assert, location.child(property), report);
+                    runAssertion({
+                        values: value,
+                        rawValues: rawNode[property],
+                        assert,
+                        location: currentLocation.child(property),
+                        report,
+                    });
                 }
             }
             else {
-                runAssertion(Object.keys(node), assert, location.key(), report);
+                const value = assert.name === 'ref' ? rawNode : Object.keys(node);
+                runAssertion({
+                    values: Object.keys(node),
+                    rawValues: value,
+                    assert,
+                    location: currentLocation,
+                    report,
+                });
             }
         }
     };
@@ -113,15 +127,20 @@ function isOrdered(value, options) {
     return true;
 }
 exports.isOrdered = isOrdered;
-function runAssertion(values, assert, location, report) {
-    const lintResult = asserts_1.asserts[assert.name](values, assert.conditions);
-    if (!lintResult) {
+function runAssertion({ values, rawValues, assert, location, report }) {
+    const lintResult = asserts_1.asserts[assert.name](values, assert.conditions, location, rawValues);
+    if (!lintResult.isValid) {
         report({
             message: assert.message || `The ${assert.assertId} doesn't meet required conditions`,
-            location,
+            location: lintResult.location || location,
             forceSeverity: assert.severity,
             suggest: assert.suggest,
             ruleId: assert.assertId,
         });
     }
 }
+function regexFromString(input) {
+    const matches = input.match(/^\/(.*)\/(.*)|(.*)/);
+    return matches && new RegExp(matches[1] || matches[3], matches[2]);
+}
+exports.regexFromString = regexFromString;

package/lib/types/oas3.js

@@ -276,9 +276,6 @@ const Schema = {
             if (typeof value === 'boolean') {
                 return { type: 'boolean' };
             }
-            else if (Array.isArray(value)) {
-                return _1.listOf('Schema');
-            }
             else {
                 return 'Schema';
             }