@redocly/openapi-core 1.0.0-beta.111 → 1.0.0-beta.112

package/src/rules/common/assertions/__tests__/utils.test.ts

@@ -1,3 +1,4 @@
+import { Assertion, AssertionDefinition } from '..';
 import { isOrdered, buildVisitorObject, getIntersectionLength } from '../utils';
 
 describe('Oas3 assertions', () => {
@@ -25,29 +26,43 @@ describe('Oas3 assertions', () => {
 
     describe('buildVisitorObject', () => {
       it('should return a consistent visitor structure', () => {
-        const context = [
+        const where: AssertionDefinition[] = [
           {
-            type: 'Foo',
-            matchParentKeys: ['test'],
+            subject: {
+              type: 'Foo',
+              filterInParentKeys: ['test'],
+            },
+            assertions: {},
           },
           {
-            type: 'Bar',
-            matchParentKeys: ['test'],
+            subject: {
+              type: 'Bar',
+              filterInParentKeys: ['test'],
+            },
+            assertions: {},
           },
           {
-            type: 'Roof',
-            matchParentKeys: ['test'],
+            subject: {
+              type: 'Roof',
+              filterInParentKeys: ['test'],
+            },
+            assertions: {},
           },
-        ];
+        ] as AssertionDefinition[];
 
-        const visitors = buildVisitorObject('Bar', context, () => {}) as any;
+        const visitors = buildVisitorObject(
+          { subject: { type: 'Bar' }, where, assertions: {} } as Assertion,
+          () => {}
+        );
 
         expect(visitors).toMatchInlineSnapshot(`
           Object {
             "Foo": Object {
               "Bar": Object {
                 "Roof": Object {
-                  "Bar": [Function],
+                  "Bar": Object {
+                    "enter": [Function],
+                  },
                   "skip": [Function],
                 },
                 "skip": [Function],
@@ -59,24 +74,35 @@ describe('Oas3 assertions', () => {
       });
 
       it('should return the right visitor structure', () => {
-        const context = [
+        const where = [
           {
-            type: 'Operation',
-            matchParentKeys: ['put'],
+            subject: {
+              type: 'Operation',
+              filterInParentKeys: ['put'],
+            },
+            assertions: {},
           },
           {
-            type: 'Responses',
-            matchParentKeys: [201, 200],
+            subject: {
+              type: 'Responses',
+              filterInParentKeys: [201, 200],
+            },
+            assertions: {},
           },
         ];
 
-        const visitors = buildVisitorObject('MediaTypesMap', context, () => {}) as any;
+        const visitors = buildVisitorObject(
+          { subject: { type: 'MediaTypesMap' }, where, assertions: {} } as Assertion,
+          () => {}
+        );
 
         expect(visitors).toMatchInlineSnapshot(`
           Object {
             "Operation": Object {
               "Responses": Object {
-                "MediaTypesMap": [Function],
+                "MediaTypesMap": Object {
+                  "enter": [Function],
+                },
                 "skip": [Function],
               },
               "skip": [Function],

package/src/rules/common/assertions/asserts.ts

@@ -9,12 +9,33 @@ import {
   regexFromString,
 } from './utils';
 
-type Asserts = Record<
-  string,
-  (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult[]
->;
+export type AssertionFn = (
+  value: any,
+  condition: any,
+  baseLocation: Location,
+  rawValue?: any
+) => AssertResult[];
 
-export const runOnKeysSet = new Set([
+export type Asserts = {
+  pattern: AssertionFn;
+  enum: AssertionFn;
+  defined: AssertionFn;
+  required: AssertionFn;
+  disallowed: AssertionFn;
+  undefined: AssertionFn;
+  nonEmpty: AssertionFn;
+  minLength: AssertionFn;
+  maxLength: AssertionFn;
+  casing: AssertionFn;
+  sortOrder: AssertionFn;
+  mutuallyExclusive: AssertionFn;
+  mutuallyRequired: AssertionFn;
+  requireAny: AssertionFn;
+  ref: AssertionFn;
+  const: AssertionFn;
+};
+
+export const runOnKeysSet = new Set<keyof Asserts>([
   'mutuallyExclusive',
   'mutuallyRequired',
   'enum',
@@ -27,8 +48,10 @@ export const runOnKeysSet = new Set([
   'required',
   'requireAny',
   'ref',
+  'const',
+  'defined', // In case if `property` for assertions is not added
 ]);
-export const runOnValuesSet = new Set([
+export const runOnValuesSet = new Set<keyof Asserts>([
   'pattern',
   'enum',
   'defined',
@@ -39,6 +62,7 @@ export const runOnValuesSet = new Set([
   'casing',
   'sortOrder',
   'ref',
+  'const',
 ]);
 
 export const asserts: Asserts = {
@@ -106,6 +130,34 @@ export const asserts: Asserts = {
       )
       .filter(isTruthy);
   },
+  const: (
+    value: string | number | boolean | string[] | number[],
+    condition: string | number | boolean,
+    baseLocation: Location
+  ) => {
+    if (typeof value === 'undefined') return [];
+
+    if (Array.isArray(value)) {
+      return value
+        .map(
+          (_val) =>
+            condition !== _val && {
+              message: `"${_val}" should be equal ${condition} `,
+              location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+            }
+        )
+        .filter(isTruthy);
+    } else {
+      return value !== condition
+        ? [
+            {
+              message: `${value} should be equal ${condition}`,
+              location: baseLocation,
+            },
+          ]
+        : [];
+    }
+  },
   undefined: (value: any, condition: boolean = true, baseLocation: Location) => {
     const isUndefined = typeof value === 'undefined';
     const isValid = condition ? isUndefined : !isUndefined;
@@ -210,7 +262,7 @@ export const asserts: Asserts = {
           },
         ];
   },
-  ref: (_value: any, condition: string | boolean, baseLocation, rawValue: any) => {
+  ref: (_value: any, condition: string | boolean, baseLocation: Location, rawValue: any) => {
     if (typeof rawValue === 'undefined') return []; // property doesn't exist, no need to lint it with this assert
     const hasRef = rawValue.hasOwnProperty('$ref');
     if (typeof condition === 'boolean') {
@@ -237,7 +289,7 @@ export const asserts: Asserts = {
   },
 };
 
-export function buildAssertCustomFunction(fn: CustomFunction) {
+export function buildAssertCustomFunction(fn: CustomFunction): AssertionFn {
   return (value: string[], options: any, baseLocation: Location) =>
     fn.call(null, value, options, baseLocation);
 }

package/src/rules/common/assertions/index.ts

@@ -1,65 +1,55 @@
-import { asserts, runOnKeysSet, runOnValuesSet } from './asserts';
-import { AssertToApply, buildSubjectVisitor, buildVisitorObject } from './utils';
-import { Oas2Rule, Oas3Rule } from '../../../visitors';
+import { asserts, AssertionFn } from './asserts';
+import { buildSubjectVisitor, buildVisitorObject } from './utils';
+import { Oas2Visitor, Oas3Visitor } from '../../../visitors';
+import { RuleSeverity } from '../../../config';
+import { isString } from '../../../utils';
+
+export type AssertionLocators = {
+  filterInParentKeys?: (string | number)[];
+  filterOutParentKeys?: (string | number)[];
+  matchParentKeys?: string;
+};
+
+export type AssertionDefinition = {
+  subject: {
+    type: string;
+    property?: string | string[];
+  } & AssertionLocators;
+  assertions: { [name in keyof typeof asserts]?: AssertionFn };
+};
 
-export const Assertions: Oas3Rule | Oas2Rule = (opts: object) => {
-  const visitors: any[] = [];
+export type RawAssertion = AssertionDefinition & {
+  where?: AssertionDefinition[];
+  message?: string;
+  suggest?: string[];
+  severity?: RuleSeverity;
+};
+
+export type Assertion = RawAssertion & { assertionId: string };
+
+export const Assertions = (opts: Record<string, Assertion>) => {
+  const visitors: (Oas2Visitor | Oas3Visitor)[] = [];
 
   // 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/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: any[] = Object.values(opts).filter(
+  const assertions: Assertion[] = Object.values(opts).filter(
     (opt: unknown) => 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: string[] = Array.isArray(assertion.subject)
-      ? assertion.subject
-      : [assertion.subject];
-
-    const assertsToApply: AssertToApply[] = Object.keys(asserts)
-      .filter((assertName: string) => assertion[assertName] !== undefined)
-      .map((assertName: string) => {
-        return {
-          name: assertName,
-          conditions: assertion[assertName],
-          runsOnKeys: runOnKeysSet.has(assertName),
-          runsOnValues: runOnValuesSet.has(assertName),
-        };
-      });
-
-    const shouldRunOnKeys: AssertToApply | undefined = assertsToApply.find(
-      (assert: AssertToApply) => assert.runsOnKeys && !assert.runsOnValues
-    );
-    const shouldRunOnValues: AssertToApply | undefined = assertsToApply.find(
-      (assert: AssertToApply) => 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 (!isString(assertion.subject.type)) {
+      throw new Error(`${assertId}: 'type' (String) is required`);
     }
 
-    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 = buildSubjectVisitor(assertId, assertion, assertsToApply);
-      const visitorObject = buildVisitorObject(subject, assertion.context, subjectVisitor);
-      visitors.push(visitorObject);
-    }
+    const subjectVisitor = buildSubjectVisitor(assertId, assertion);
+    const visitorObject = buildVisitorObject(assertion, subjectVisitor);
+    visitors.push(visitorObject);
   }
 
   return visitors;