@redocly/openapi-core 1.0.0-beta.91 → 1.0.0-beta.94

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

@@ -0,0 +1,89 @@
+import { isOrdered, buildVisitorObject, getIntersectionLength } from '../utils';
+
+describe('Oas3 assertions', () => {
+  describe('Utils', () => {
+    describe('getCounts', () => {
+      it('should return the right counts', () => {
+        const arr = ['foo', 'bar', 'baz'];
+        expect(getIntersectionLength(arr, ['foo'])).toBe(1);
+        expect(getIntersectionLength(arr, ['foo', 'bar', 'baz'])).toBe(3);
+        expect(getIntersectionLength(arr, ['foo', 'test', 'baz'])).toBe(2);
+        expect(getIntersectionLength(arr, ['example', 'test'])).toBe(0);
+      });
+    });
+
+    describe('isOrdered', () => {
+      it('should say if array is ordered or not in specific direction', () => {
+        expect(isOrdered(['example', 'foo', 'test'], 'asc')).toBeTruthy();
+        expect(isOrdered(['example'], 'asc')).toBeTruthy();
+        expect(isOrdered(['test', 'foo', 'example'], 'desc')).toBeTruthy();
+        expect(isOrdered(['example'], 'desc')).toBeTruthy();
+        expect(isOrdered(['example', 'test', 'foo'], 'asc')).toBeFalsy();
+        expect(isOrdered(['example', 'foo', 'test'], 'desc')).toBeFalsy();
+      });
+    });
+
+    describe('buildVisitorObject', () => {
+      it('should return a consistent visitor structure', () => {
+        const context = [
+          {
+            type: 'Foo',
+            matchParentKeys: ['test'],
+          },
+          {
+            type: 'Bar',
+            matchParentKeys: ['test'],
+          },
+          {
+            type: 'Roof',
+            matchParentKeys: ['test'],
+          },
+        ];
+
+        const visitors = buildVisitorObject('Bar', context, () => {}) as any;
+
+        expect(visitors).toMatchInlineSnapshot(`
+          Object {
+            "Foo": Object {
+              "Bar": Object {
+                "Roof": Object {
+                  "Bar": [Function],
+                  "skip": [Function],
+                },
+                "skip": [Function],
+              },
+              "skip": [Function],
+            },
+          }
+        `);
+      });
+
+      it('should return the right visitor structure', () => {
+        const context = [
+          {
+            type: 'Operation',
+            matchParentKeys: ['put'],
+          },
+          {
+            type: 'ResponsesMap',
+            matchParentKeys: [201, 200],
+          },
+        ];
+
+        const visitors = buildVisitorObject('MediaTypeMap', context, () => {}) as any;
+
+        expect(visitors).toMatchInlineSnapshot(`
+          Object {
+            "Operation": Object {
+              "ResponsesMap": Object {
+                "MediaTypeMap": [Function],
+                "skip": [Function],
+              },
+              "skip": [Function],
+            },
+          }
+        `);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,137 @@
+import { OrderOptions, OrderDirection, isOrdered, getIntersectionLength } from './utils';
+
+type Asserts = Record<string, (value: any, condition: any) => boolean>;
+
+export const runOnKeysSet = new Set([
+  'mutuallyExclusive',
+  'mutuallyRequired',
+  'enum',
+  'pattern',
+  'minLength',
+  'maxLength',
+  'casing',
+  'sortOrder',
+  'disallowed',
+  'required',
+]);
+export const runOnValuesSet = new Set([
+  'pattern',
+  'enum',
+  'defined',
+  'undefined',
+  'nonEmpty',
+  'minLength',
+  'maxLength',
+  'casing',
+  'sortOrder',
+]);
+
+export const asserts: Asserts = {
+  pattern: (value: string | string[], condition: string): boolean => {
+    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: string | string[], condition: string[]): boolean => {
+    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: string | undefined, condition: boolean = true): boolean => {
+    const isDefined = typeof value !== 'undefined';
+    return condition ? isDefined : !isDefined;
+  },
+  required: (value: string[], keys: string[]): boolean => {
+    for (const requiredKey of keys) {
+      if (!value.includes(requiredKey)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  disallowed: (value: string | string[], condition: string[]): boolean => {
+    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: any, condition: boolean = true): boolean => {
+    const isUndefined = typeof value === 'undefined';
+    return condition ? isUndefined : !isUndefined;
+  },
+  nonEmpty: (value: string | undefined | null, condition: boolean = true): boolean => {
+    const isEmpty = typeof value === 'undefined' || value === null || value === '';
+    return condition ? !isEmpty : isEmpty;
+  },
+  minLength: (value: string | any[], condition: number): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    return value.length >= condition;
+  },
+  maxLength: (value: string | any[], condition: number): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    return value.length <= condition;
+  },
+  casing: (value: string | string[], condition: string): boolean => {
+    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: any[], condition: OrderOptions | OrderDirection): boolean => {
+    if (typeof value === 'undefined') return true;
+    return isOrdered(value, condition);
+  },
+  mutuallyExclusive: (value: string[], condition: string[]): boolean => {
+    return getIntersectionLength(value, condition) < 2;
+  },
+  mutuallyRequired: (value: string[], condition: string[]): boolean => {
+    return getIntersectionLength(value, condition) > 0
+      ? getIntersectionLength(value, condition) === condition.length
+      : true;
+  },
+};

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

@@ -0,0 +1,75 @@
+import { asserts, runOnKeysSet, runOnValuesSet } from './asserts';
+import { AssertToApply, buildSubjectVisitor, buildVisitorObject } from './utils';
+import { Oas2Rule, Oas3Rule } from '../../../visitors';
+
+export const Assertions: Oas3Rule | Oas2Rule = (opts: object) => {
+  let visitors: any[] = [];
+
+  // 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: any[] = 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 {
+          assertId,
+          name: assertName,
+          conditions: assertion[assertName],
+          message: assertion.message,
+          severity: assertion.severity || 'error',
+          suggest: assertion.suggest || [],
+          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 (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(
+        assertion.property,
+        assertsToApply,
+        assertion.context,
+      );
+      const visitorObject = buildVisitorObject(subject, assertion.context, subjectVisitor);
+      visitors.push(visitorObject);
+    }
+  }
+
+  return visitors;
+};

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

@@ -0,0 +1,164 @@
+import { Problem, ProblemSeverity, UserContext } from '../../../walk';
+import { asserts } from './asserts';
+
+export type OrderDirection = 'asc' | 'desc';
+
+export type OrderOptions = {
+  direction: OrderDirection;
+  property: string;
+};
+
+export type AssertToApply = {
+  name: string;
+  assertId?: string;
+  conditions: any;
+  message?: string;
+  severity?: ProblemSeverity;
+  suggest?: string[];
+  runsOnKeys: boolean;
+  runsOnValues: boolean;
+};
+
+export function buildVisitorObject(
+  subject: string,
+  context: Record<string, any>[],
+  subjectVisitor: any,
+) {
+  if (!context) {
+    return { [subject]: subjectVisitor };
+  }
+
+  let currentVisitorLevel: Record<string, any> = {};
+  const visitor: Record<string, any> = 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: any, key: string) => {
+          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;
+}
+
+export function buildSubjectVisitor(
+  properties: string | string[],
+  asserts: AssertToApply[],
+  context?: Record<string, any>[],
+) {
+  return function (node: any, { report, location, key, type }: UserContext) {
+    // 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);
+      }
+    }
+  };
+}
+
+export function getIntersectionLength(keys: string[], properties: string[]): number {
+  const props = new Set(properties);
+  let count = 0;
+  for (const key of keys) {
+    if (props.has(key)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+export function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean {
+  const direction = (options as OrderOptions).direction || (options as OrderDirection);
+  const property = (options as OrderOptions).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;
+}
+
+function runAssertion(
+  values: string | string[],
+  assert: AssertToApply,
+  location: any,
+  report: (problem: Problem) => void,
+) {
+  const lintResult = 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/src/rules/oas2/index.ts

@@ -14,6 +14,7 @@ import { NoEnumTypeMismatch } from '../common/no-enum-type-mismatch';
 import { NoPathTrailingSlash } from '../common/no-path-trailing-slash';
 import { Operation2xxResponse } from '../common/operation-2xx-response';
 import { Operation4xxResponse } from '../common/operation-4xx-response';
+import { Assertions } from '../common/assertions';
 import { OperationIdUnique } from '../common/operation-operationId-unique';
 import { OperationParametersUnique } from '../common/operation-parameters-unique';
 import { PathParamsDefined } from '../common/path-params-defined';
@@ -53,6 +54,7 @@ export const rules = {
   'no-path-trailing-slash': NoPathTrailingSlash as Oas2Rule,
   'operation-2xx-response': Operation2xxResponse as Oas2Rule,
   'operation-4xx-response': Operation4xxResponse as Oas2Rule,
+  'assertions': Assertions as Oas2Rule,
   'operation-operationId-unique': OperationIdUnique as Oas2Rule,
   'operation-parameters-unique': OperationParametersUnique as Oas2Rule,
   'path-parameters-defined': PathParamsDefined as Oas2Rule,

package/src/rules/oas3/__tests__/spec/servers.test.ts

@@ -176,7 +176,7 @@ describe('OpenAPI Schema', () => {
       Array [
         Object {
           "location": "#/servers",
-          "message": "Expected type \`Server_List\` (array) but got \`object\`",
+          "message": "Expected type \`ServerList\` (array) but got \`object\`",
         },
       ]
     `);

package/src/rules/oas3/index.ts

@@ -2,6 +2,7 @@ import { Oas3RuleSet } from '../../oas-types';
 import { OasSpec } from '../common/spec';
 import { Operation2xxResponse } from '../common/operation-2xx-response';
 import { Operation4xxResponse } from '../common/operation-4xx-response';
+import { Assertions } from '../common/assertions';
 import { OperationIdUnique } from '../common/operation-operationId-unique';
 import { OperationParametersUnique } from '../common/operation-parameters-unique';
 import { PathParamsDefined } from '../common/path-params-defined';
@@ -53,6 +54,7 @@ export const rules = {
   'info-license-url': InfoLicenseUrl,
   'operation-2xx-response': Operation2xxResponse,
   'operation-4xx-response': Operation4xxResponse,
+  'assertions': Assertions,
   'operation-operationId-unique': OperationIdUnique,
   'operation-parameters-unique': OperationParametersUnique,
   'path-parameters-defined': PathParamsDefined,

package/src/types/index.ts

@@ -49,7 +49,7 @@ type NormalizedResolveTypeFn = (
 
 export function listOf(typeName: string) {
   return {
-    name: typeName + '_List',
+    name: `${typeName}List`,
     properties: {},
     items: typeName,
   };
@@ -57,7 +57,7 @@ export function listOf(typeName: string) {
 
 export function mapOf(typeName: string) {
   return {
-    name: typeName + '_Map',
+    name: `${typeName}Map`,
     properties: {},
     additionalProperties: () => typeName,
   };

package/src/types/oas3_1.ts

@@ -1,5 +1,5 @@
 import { NodeType, listOf, mapOf } from '.';
-import { Oas3Types } from './oas3'
+import { Oas3Types } from './oas3';
 
 const DefinitionRoot: NodeType = {
   properties: {
@@ -15,7 +15,7 @@ const DefinitionRoot: NodeType = {
     jsonSchemaDialect: { type: 'string' },
   },
   required: ['openapi', 'info'],
-  requiredOneOf: ['paths', 'components', 'webhooks']
+  requiredOneOf: ['paths', 'components', 'webhooks'],
 };
 
 const License: NodeType = {
@@ -106,11 +106,14 @@ const Schema: NodeType = {
     enum: { type: 'array' },
     type: (value: any) => {
       if (Array.isArray(value)) {
-        return { type: 'array', items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] } }
+        return {
+          type: 'array',
+          items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+        };
       } else {
         return {
           enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
-        }
+        };
       }
     },
     allOf: listOf('Schema'),
@@ -126,7 +129,13 @@ const Schema: NodeType = {
     patternProperties: { type: 'object' },
     propertyNames: 'Schema',
     unevaluatedItems: 'Schema',
-    unevaluatedProperties: 'Schema',
+    unevaluatedProperties: (value: unknown) => {
+      if (typeof value === 'boolean') {
+        return { type: 'boolean' };
+      } else {
+        return 'Schema';
+      }
+    },
     summary: { type: 'string' },
     properties: 'SchemaProperties',
     items: (value: any) => {
@@ -196,9 +205,25 @@ const SecurityScheme: NodeType = {
           case 'clientCredentials':
             return ['type', 'flows', 'tokenUrl', 'refreshUrl', 'description', 'scopes'];
           case 'authorizationCode':
-            return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+            return [
+              'type',
+              'flows',
+              'authorizationUrl',
+              'refreshUrl',
+              'tokenUrl',
+              'description',
+              'scopes',
+            ];
           default:
-            return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+            return [
+              'type',
+              'flows',
+              'authorizationUrl',
+              'refreshUrl',
+              'tokenUrl',
+              'description',
+              'scopes',
+            ];
         }
       case 'openIdConnect':
         return ['type', 'openIdConnectUrl', 'description'];

package/src/visitors.ts

@@ -244,8 +244,8 @@ export type NormalizedOasVisitors<T extends BaseVisitor> = {
   };
 };
 
-export type Oas3Rule = (options: Record<string, any>) => Oas3Visitor;
-export type Oas2Rule = (options: Record<string, any>) => Oas2Visitor;
+export type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
+export type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
 export type Oas3Preprocessor = (options: Record<string, any>) => Oas3TransformVisitor;
 export type Oas2Preprocessor = (options: Record<string, any>) => Oas2TransformVisitor;
 export type Oas3Decorator = (options: Record<string, any>) => Oas3TransformVisitor;

package/src/walk.ts

@@ -63,6 +63,7 @@ export type Problem = {
   location?: Partial<LocationObject> | Array<Partial<LocationObject>>;
   from?: LocationObject;
   forceSeverity?: ProblemSeverity;
+  ruleId?: string;
 };
 
 export type NormalizedProblem = {
@@ -397,7 +398,7 @@ export function walkDocument<T>(opts: {
         : [{ ...currentLocation, reportOnKey: false }];
 
       ctx.problems.push({
-        ruleId,
+        ruleId: opts.ruleId || ruleId,
         severity: opts.forceSeverity || severity,
         ...opts,
         suggest: opts.suggest || [],