@redocly/openapi-core 1.0.0-beta.90 → 1.0.0-beta.93

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/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/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 || [],