@redocly/openapi-core 1.0.0-beta.102 → 1.0.0-beta.105

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,25 +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) => {
-        return utils_1.getIntersectionLength(value, condition) >= 1;
+    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;