@redocly/openapi-core 1.0.0-beta.124 → 1.0.0-beta.126

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

@@ -1,4 +1,4 @@
-import { Assertion, Assertions } from '../.';
+import { Assertions } from '../.';
 
 const opts = {
   '0': {

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

@@ -1,5 +1,8 @@
 import { Assertion, AssertionDefinition } from '..';
-import { isOrdered, buildVisitorObject, getIntersectionLength } from '../utils';
+import { AssertionContext } from '../../../../config';
+import { Location } from '../../../../ref-utils';
+import { Source } from '../../../../resolve';
+import { isOrdered, buildVisitorObject, getIntersectionLength, runAssertion } from '../utils';
 
 describe('Oas3 assertions', () => {
   describe('Utils', () => {
@@ -111,5 +114,123 @@ describe('Oas3 assertions', () => {
         `);
       });
     });
+
+    describe('runAssertion', () => {
+      const baseLocation = new Location(jest.fn() as any as Source, 'pointer');
+      const rawLocation = new Location(jest.fn() as any as Source, 'raw-pointer');
+      // { $ref: 'text' }, true, {...assertionProperties, rawValue:  { $ref: 'text' }}
+
+      const ctxStub = {
+        location: baseLocation,
+        node: {
+          property: 'test',
+        },
+        rawNode: {
+          property: 'test',
+        },
+        rawLocation: rawLocation,
+      } as AssertionContext;
+
+      it('should catch error cause property should be not defined with assertionProperty', () => {
+        const result = runAssertion({
+          assert: {
+            name: 'defined',
+            conditions: false,
+            runsOnKeys: true,
+            runsOnValues: false,
+          },
+          ctx: ctxStub,
+          assertionProperty: 'property',
+        });
+
+        const expectedLocation = new Location(jest.fn() as any as Source, 'pointer/property');
+
+        expect(JSON.stringify(result)).toEqual(
+          JSON.stringify([
+            {
+              message: 'Should be not defined',
+              location: expectedLocation,
+            },
+          ])
+        );
+      });
+
+      it('should pass cause property defined', () => {
+        const result = runAssertion({
+          assert: {
+            name: 'defined',
+            conditions: true,
+            runsOnKeys: true,
+            runsOnValues: false,
+          },
+          ctx: ctxStub,
+          assertionProperty: 'property',
+        });
+
+        expect(result).toEqual([]);
+      });
+
+      it('should failure cause property does not passed', () => {
+        const result = runAssertion({
+          assert: {
+            name: 'defined',
+            conditions: false,
+            runsOnKeys: true,
+            runsOnValues: false,
+          },
+          ctx: ctxStub,
+        });
+
+        expect(result).toEqual([
+          {
+            message: 'Should be not defined',
+            location: baseLocation,
+          },
+        ]);
+      });
+
+      it('should pass with ref assertion cause it is defined', () => {
+        const result = runAssertion({
+          assert: {
+            name: 'ref',
+            conditions: true,
+            runsOnKeys: true,
+            runsOnValues: false,
+          },
+          ctx: {
+            ...ctxStub,
+            rawNode: {
+              $ref: 'test',
+            },
+          },
+        });
+
+        expect(result).toEqual([]);
+      });
+
+      it('should failure with ref assertion cause it is defined', () => {
+        const result = runAssertion({
+          assert: {
+            name: 'ref',
+            conditions: false,
+            runsOnKeys: true,
+            runsOnValues: false,
+          },
+          ctx: {
+            ...ctxStub,
+            rawNode: {
+              $ref: 'test',
+            },
+          },
+        });
+
+        expect(result).toEqual([
+          {
+            message: 'should not use $ref',
+            location: rawLocation,
+          },
+        ]);
+      });
+    });
   });
 });

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

@@ -1,4 +1,4 @@
-import { AssertResult, CustomFunction } from 'core/src/config/types';
+import { AssertionContext, AssertResult, CustomFunction } from 'core/src/config/types';
 import { Location } from '../../../ref-utils';
 import { isPlainObject, isString as runOnValue, isTruthy } from '../../../utils';
 import {
@@ -9,12 +9,9 @@ import {
   regexFromString,
 } from './utils';
 
-export type AssertionFn = (
-  value: any,
-  condition: any,
-  baseLocation: Location,
-  rawValue?: any
-) => AssertResult[];
+export type AssertionFnContext = AssertionContext & { baseLocation: Location; rawValue?: any };
+
+export type AssertionFn = (value: any, condition: any, ctx: AssertionFnContext) => AssertResult[];
 
 export type Asserts = {
   pattern: AssertionFn;
@@ -69,7 +66,7 @@ export const runOnValuesSet = new Set<keyof Asserts>([
 ]);
 
 export const asserts: Asserts = {
-  pattern: (value: string | string[], condition: string, baseLocation: Location) => {
+  pattern: (value: string | string[], condition: string, { baseLocation }: AssertionFnContext) => {
     if (typeof value === 'undefined' || isPlainObject(value)) return []; // property doesn't exist or is an object, no need to lint it with this assert
     const values = Array.isArray(value) ? value : [value];
     const regex = regexFromString(condition);
@@ -84,7 +81,11 @@ export const asserts: Asserts = {
       )
       .filter(isTruthy);
   },
-  notPattern: (value: string | string[], condition: string, baseLocation: Location) => {
+  notPattern: (
+    value: string | string[],
+    condition: string,
+    { baseLocation }: AssertionFnContext
+  ) => {
     if (typeof value === 'undefined' || isPlainObject(value)) return []; // property doesn't exist or is an object, no need to lint it with this assert
     const values = Array.isArray(value) ? value : [value];
     const regex = regexFromString(condition);
@@ -99,7 +100,7 @@ export const asserts: Asserts = {
       )
       .filter(isTruthy);
   },
-  enum: (value: string | string[], condition: string[], baseLocation: Location) => {
+  enum: (value: string | string[], condition: string[], { baseLocation }: AssertionFnContext) => {
     if (typeof value === 'undefined' || isPlainObject(value)) return []; // property doesn't exist or is an object, no need to lint it with this assert
     const values = Array.isArray(value) ? value : [value];
     return values
@@ -112,7 +113,11 @@ export const asserts: Asserts = {
       )
       .filter(isTruthy);
   },
-  defined: (value: string | undefined, condition: boolean = true, baseLocation: Location) => {
+  defined: (
+    value: string | undefined,
+    condition: boolean = true,
+    { baseLocation }: AssertionFnContext
+  ) => {
     const isDefined = typeof value !== 'undefined';
     const isValid = condition ? isDefined : !isDefined;
     return isValid
@@ -124,7 +129,7 @@ export const asserts: Asserts = {
           },
         ];
   },
-  required: (value: string[], keys: string[], baseLocation: Location) => {
+  required: (value: string[], keys: string[], { baseLocation }: AssertionFnContext) => {
     return keys
       .map(
         (requiredKey) =>
@@ -135,7 +140,11 @@ export const asserts: Asserts = {
       )
       .filter(isTruthy);
   },
-  disallowed: (value: string | string[], condition: string[], baseLocation: Location) => {
+  disallowed: (
+    value: string | string[],
+    condition: string[],
+    { baseLocation }: AssertionFnContext
+  ) => {
     if (typeof value === 'undefined' || isPlainObject(value)) return []; // property doesn't exist or is an object, no need to lint it with this assert
     const values = Array.isArray(value) ? value : [value];
     return values
@@ -151,7 +160,7 @@ export const asserts: Asserts = {
   const: (
     value: string | number | boolean | string[] | number[],
     condition: string | number | boolean,
-    baseLocation: Location
+    { baseLocation }: AssertionFnContext
   ) => {
     if (typeof value === 'undefined') return [];
 
@@ -176,7 +185,7 @@ export const asserts: Asserts = {
         : [];
     }
   },
-  undefined: (value: unknown, condition: boolean = true, baseLocation: Location) => {
+  undefined: (value: unknown, condition: boolean = true, { baseLocation }: AssertionFnContext) => {
     const isUndefined = typeof value === 'undefined';
     const isValid = condition ? isUndefined : !isUndefined;
     return isValid
@@ -191,7 +200,7 @@ export const asserts: Asserts = {
   nonEmpty: (
     value: string | undefined | null,
     condition: boolean = true,
-    baseLocation: Location
+    { baseLocation }: AssertionFnContext
   ) => {
     const isEmpty = typeof value === 'undefined' || value === null || value === '';
     const isValid = condition ? !isEmpty : isEmpty;
@@ -204,15 +213,25 @@ export const asserts: Asserts = {
           },
         ];
   },
-  minLength: (value: string | any[], condition: number, baseLocation: Location) => {
+  minLength: (value: string | any[], condition: number, { baseLocation }: AssertionFnContext) => {
     if (typeof value === 'undefined' || value.length >= condition) return []; // property doesn't exist, no need to lint it with this assert
-    return [{ message: `Should have at least ${condition} characters`, location: baseLocation }];
+    return [
+      {
+        message: `Should have at least ${condition} characters`,
+        location: baseLocation,
+      },
+    ];
   },
-  maxLength: (value: string | any[], condition: number, baseLocation: Location) => {
+  maxLength: (value: string | any[], condition: number, { baseLocation }: AssertionFnContext) => {
     if (typeof value === 'undefined' || value.length <= condition) return []; // property doesn't exist, no need to lint it with this assert
-    return [{ message: `Should have at most ${condition} characters`, location: baseLocation }];
+    return [
+      {
+        message: `Should have at most ${condition} characters`,
+        location: baseLocation,
+      },
+    ];
   },
-  casing: (value: string | string[], condition: string, baseLocation: Location) => {
+  casing: (value: string | string[], condition: string, { baseLocation }: AssertionFnContext) => {
     if (typeof value === 'undefined' || isPlainObject(value)) return []; // property doesn't exist or is an object, no need to lint it with this assert
     const values = Array.isArray(value) ? value : [value];
     const casingRegexes: Record<string, RegExp> = {
@@ -237,7 +256,7 @@ export const asserts: Asserts = {
   sortOrder: (
     value: unknown[],
     condition: OrderOptions | OrderDirection,
-    baseLocation: Location
+    { baseLocation }: AssertionFnContext
   ) => {
     const direction = (condition as OrderOptions).direction || (condition as OrderDirection);
     const property = (condition as OrderOptions).property;
@@ -260,7 +279,11 @@ export const asserts: Asserts = {
       },
     ];
   },
-  mutuallyExclusive: (value: string[], condition: string[], baseLocation: Location) => {
+  mutuallyExclusive: (
+    value: string[],
+    condition: string[],
+    { baseLocation }: AssertionFnContext
+  ) => {
     if (getIntersectionLength(value, condition) < 2) return [];
     return [
       {
@@ -269,7 +292,11 @@ export const asserts: Asserts = {
       },
     ];
   },
-  mutuallyRequired: (value: string[], condition: string[], baseLocation: Location) => {
+  mutuallyRequired: (
+    value: string[],
+    condition: string[],
+    { baseLocation }: AssertionFnContext
+  ) => {
     const isValid =
       getIntersectionLength(value, condition) > 0
         ? getIntersectionLength(value, condition) === condition.length
@@ -283,7 +310,7 @@ export const asserts: Asserts = {
           },
         ];
   },
-  requireAny: (value: string[], condition: string[], baseLocation: Location) => {
+  requireAny: (value: string[], condition: string[], { baseLocation }: AssertionFnContext) => {
     return getIntersectionLength(value, condition) >= 1
       ? []
       : [
@@ -293,7 +320,11 @@ export const asserts: Asserts = {
           },
         ];
   },
-  ref: (_value: unknown, condition: string | boolean, baseLocation: Location, rawValue: any) => {
+  ref: (
+    _value: unknown,
+    condition: string | boolean,
+    { baseLocation, rawValue }: AssertionFnContext
+  ) => {
     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') {
@@ -321,6 +352,6 @@ export const asserts: Asserts = {
 };
 
 export function buildAssertCustomFunction(fn: CustomFunction): AssertionFn {
-  return (value: string[], options: any, baseLocation: Location) =>
-    fn.call(null, value, options, baseLocation);
+  return (value: string[], options: any, ctx: AssertionFnContext) =>
+    fn.call(null, value, options, ctx);
 }

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

@@ -1,8 +1,8 @@
 import { asserts, runOnKeysSet, runOnValuesSet, Asserts } from './asserts';
 import { colorize } from '../../../logger';
-import { isRef, Location } from '../../../ref-utils';
+import { isRef } from '../../../ref-utils';
 import { isTruthy, keysOf, isString } from '../../../utils';
-import type { AssertResult } from '../../../config';
+import type { AssertionContext, AssertResult } from '../../../config';
 import type { Assertion, AssertionDefinition, AssertionLocators } from '.';
 import type {
   Oas2Visitor,
@@ -10,6 +10,7 @@ import type {
   SkipFunctionContext,
   VisitFunction,
 } from '../../../visitors';
+import { UserContext } from 'core/src/walk';
 
 export type OrderDirection = 'asc' | 'desc';
 
@@ -25,8 +26,10 @@ export type AssertToApply = {
   runsOnValues: boolean;
 };
 
-type AssertionContext = SkipFunctionContext & {
-  node: any;
+type RunAssertionParams = {
+  ctx: AssertionContext;
+  assert: AssertToApply;
+  assertionProperty?: string;
 };
 
 const assertionMessageTemplates = {
@@ -96,35 +99,27 @@ function getAssertionProperties({ subject }: AssertionDefinition): string[] {
 function applyAssertions(
   assertionDefinition: AssertionDefinition,
   asserts: AssertToApply[],
-  { rawLocation, rawNode, resolve, location, node }: AssertionContext
+  ctx: AssertionContext
 ): AssertResult[] {
   const properties = getAssertionProperties(assertionDefinition);
   const assertResults: Array<AssertResult[]> = [];
 
   for (const assert of asserts) {
-    const currentLocation = assert.name === 'ref' ? rawLocation : location;
-
     if (properties.length) {
       for (const property of properties) {
-        // we can have resolvable scalar so need to resolve value here.
-        const value = isRef(node[property]) ? resolve(node[property])?.node : node[property];
         assertResults.push(
           runAssertion({
-            values: value,
-            rawValues: rawNode[property],
             assert,
-            location: currentLocation.child(property),
+            ctx,
+            assertionProperty: property,
           })
         );
       }
     } else {
-      const value = Array.isArray(node) ? node : Object.keys(node);
       assertResults.push(
         runAssertion({
-          values: value,
-          rawValues: rawNode,
           assert,
-          location: currentLocation,
+          ctx,
         })
       );
     }
@@ -139,7 +134,7 @@ export function buildVisitorObject(
 ): Oas2Visitor | Oas3Visitor {
   const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
   const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
-    ? (node: any, key: string | number) =>
+    ? (_: any, key: string | number) =>
         !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
     : undefined;
   const targetVisitor: Oas2Visitor | Oas3Visitor = {
@@ -169,19 +164,9 @@ export function buildVisitorObject(
     const locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
     const assertsToApply = getAssertsToApply(assertionDefinitionNode);
 
-    const skipFunction = (
-      node: unknown,
-      key: string | number,
-      { location, rawLocation, resolve, rawNode }: SkipFunctionContext
-    ): boolean =>
+    const skipFunction = (node: unknown, key: string | number, ctx: SkipFunctionContext): boolean =>
       !locatorPredicates.every((predicate) => predicate(key)) ||
-      !!applyAssertions(assertionDefinitionNode, assertsToApply, {
-        location,
-        node,
-        rawLocation,
-        rawNode,
-        resolve,
-      }).length;
+      !!applyAssertions(assertionDefinitionNode, assertsToApply, { ...ctx, node }).length;
 
     const nodeVisitor = {
       ...((locatorPredicates.length || assertsToApply.length) && { skip: skipFunction }),
@@ -215,7 +200,7 @@ export function buildVisitorObject(
 }
 
 export function buildSubjectVisitor(assertId: string, assertion: Assertion): VisitFunction<any> {
-  return (node: any, { report, location, rawLocation, resolve, rawNode }) => {
+  return (node: any, ctx: UserContext) => {
     const properties = getAssertionProperties(assertion);
 
     const defaultMessage = `${colorize.blue(assertId)} failed because the ${colorize.blue(
@@ -225,10 +210,7 @@ export function buildSubjectVisitor(assertId: string, assertion: Assertion): Vis
     }`.replace(/ +/g, ' ');
 
     const problems = applyAssertions(assertion, getAssertsToApply(assertion), {
-      rawLocation,
-      rawNode,
-      resolve,
-      location,
+      ...ctx,
       node,
     });
 
@@ -236,9 +218,9 @@ export function buildSubjectVisitor(assertId: string, assertion: Assertion): Vis
       for (const problemGroup of groupProblemsByPointer(problems)) {
         const message = assertion.message || defaultMessage;
         const problemMessage = getProblemsMessage(problemGroup);
-        report({
+        ctx.report({
           message: message.replace(assertionMessageTemplates.problems, problemMessage),
-          location: getProblemsLocation(problemGroup) || location,
+          location: getProblemsLocation(problemGroup) || ctx.location,
           forceSeverity: assertion.severity || 'error',
           suggest: assertion.suggest || [],
           ruleId: assertId,
@@ -312,15 +294,35 @@ export function isOrdered(value: any[], options: OrderOptions | OrderDirection):
   return true;
 }
 
-type RunAssertionParams = {
-  values: string | string[];
-  rawValues: any;
-  assert: AssertToApply;
-  location: Location;
-};
+export function runAssertion({
+  assert,
+  ctx,
+  assertionProperty,
+}: RunAssertionParams): AssertResult[] {
+  const currentLocation = assert.name === 'ref' ? ctx.rawLocation : ctx.location;
+
+  if (assertionProperty) {
+    const values = isRef(ctx.node[assertionProperty])
+      ? ctx.resolve(ctx.node[assertionProperty])?.node
+      : ctx.node[assertionProperty];
+    const rawValues = ctx.rawNode[assertionProperty];
+
+    const location = currentLocation.child(assertionProperty);
+
+    return asserts[assert.name](values, assert.conditions, {
+      ...ctx,
+      baseLocation: location,
+      rawValue: rawValues,
+    });
+  } else {
+    const value = Array.isArray(ctx.node) ? ctx.node : Object.keys(ctx.node);
 
-function runAssertion({ values, rawValues, assert, location }: RunAssertionParams): AssertResult[] {
-  return asserts[assert.name](values, assert.conditions, location, rawValues);
+    return asserts[assert.name](value, assert.conditions, {
+      ...ctx,
+      rawValue: ctx.rawNode,
+      baseLocation: currentLocation,
+    });
+  }
 }
 
 export function regexFromString(input: string): RegExp | null {

package/src/rules/common/required-string-property-missing-min-length.ts

@@ -0,0 +1,44 @@
+import { UserContext } from '../../walk';
+import { Oas3Schema, Oas3_1Schema } from '../../typings/openapi';
+import { Oas2Schema } from 'core/src/typings/swagger';
+import { Oas3Rule } from 'core/src/visitors';
+
+export const RequiredStringPropertyMissingMinLength: Oas3Rule = () => {
+  let skipSchemaProperties: boolean;
+  let requiredPropertiesSet: Set<string>;
+
+  return {
+    Schema: {
+      enter(schema: Oas3Schema | Oas3_1Schema | Oas2Schema) {
+        if (!schema?.required) {
+          skipSchemaProperties = true;
+          return;
+        }
+        requiredPropertiesSet = new Set(schema.required);
+        skipSchemaProperties = false;
+      },
+
+      SchemaProperties: {
+        skip() {
+          return skipSchemaProperties;
+        },
+
+        Schema: {
+          enter(
+            schema: Oas3Schema | Oas3_1Schema | Oas2Schema,
+            { key, location, report }: UserContext
+          ) {
+            if (requiredPropertiesSet.has(key as string) && schema.type === 'string') {
+              if (!schema?.minLength) {
+                report({
+                  message: 'Property minLength is required.',
+                  location: location.key(),
+                });
+              }
+            }
+          },
+        },
+      },
+    },
+  };
+};

package/src/rules/oas2/index.ts

@@ -39,6 +39,7 @@ import { PathSegmentPlural } from '../common/path-segment-plural';
 import { ResponseContainsHeader } from '../common/response-contains-header';
 import { ResponseContainsProperty } from './response-contains-property';
 import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-example';
+import { RequiredStringPropertyMissingMinLength } from '../common/required-string-property-missing-min-length';
 
 export const rules = {
   spec: OasSpec as Oas2Rule,
@@ -82,6 +83,7 @@ export const rules = {
   'response-contains-header': ResponseContainsHeader as Oas2Rule,
   'response-contains-property': ResponseContainsProperty as Oas2Rule,
   'scalar-property-missing-example': ScalarPropertyMissingExample,
+  'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength,
 };
 
 export const preprocessors = {};

package/src/rules/oas3/index.ts

@@ -49,6 +49,7 @@ import { ResponseContainsProperty } from './response-contains-property';
 import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-example';
 import { SpecComponentsInvalidMapName } from './spec-components-invalid-map-name';
 import { Operation4xxProblemDetailsRfc7807 } from './operation-4xx-problem-details-rfc7807';
+import { RequiredStringPropertyMissingMinLength } from '../common/required-string-property-missing-min-length';
 
 export const rules = {
   spec: OasSpec,
@@ -102,6 +103,7 @@ export const rules = {
   'response-contains-property': ResponseContainsProperty,
   'scalar-property-missing-example': ScalarPropertyMissingExample,
   'spec-components-invalid-map-name': SpecComponentsInvalidMapName,
+  'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength,
 } as Oas3RuleSet;
 
 export const preprocessors = {};

package/src/types/redocly-yaml.ts

@@ -53,6 +53,7 @@ const builtInRulesList = [
   'response-contains-property',
   'scalar-property-missing-example',
   'spec-components-invalid-map-name',
+  'required-string-property-missing-min-length',
 ];
 const nodeTypesList = [
   'any',