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

package/src/config/config.ts

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { dirname } from 'path';
-import { red, blue } from 'colorette';
+import { red, blue, yellow, green } from 'colorette';
 import { parseYaml, stringifyYaml } from '../js-yaml';
 import { notUndefined, slash } from '../utils';
 import {
@@ -646,19 +646,22 @@ function assignExisting<T>(target: Record<string, T>, obj: Record<string, T>) {
 
 export function getMergedConfig(config: Config, entrypointAlias?: string): Config {
   return entrypointAlias
-    ? new Config({
-        ...config.rawConfig,
-        lint: getMergedLintConfig(config, entrypointAlias),
-        'features.openapi': {
-          ...config['features.openapi'],
-          ...config.apis[entrypointAlias]?.['features.openapi'],
+    ? new Config(
+        {
+          ...config.rawConfig,
+          lint: getMergedLintConfig(config, entrypointAlias),
+          'features.openapi': {
+            ...config['features.openapi'],
+            ...config.apis[entrypointAlias]?.['features.openapi'],
+          },
+          'features.mockServer': {
+            ...config['features.mockServer'],
+            ...config.apis[entrypointAlias]?.['features.mockServer'],
+          },
+          // TODO: merge everything else here
         },
-        'features.mockServer': {
-          ...config['features.mockServer'],
-          ...config.apis[entrypointAlias]?.['features.mockServer'],
-        },
-        // TODO: merge everything else here
-      })
+        config.configFile,
+      )
     : config;
 }
 
@@ -695,17 +698,20 @@ export function transformConfig(rawConfig: DeprecatedRawConfig | RawConfig): Raw
     throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
   }
   const { apiDefinitions, referenceDocs, ...rest } = rawConfig as DeprecatedRawConfig & RawConfig;
-  // TODO: put links to the changelog and uncomment this after successful release of ReferenceDocs/Redoc, Portal and Workflows
-  // if (apiDefinitions) {
-  //   process.stderr.write(
-  //     `The ${yellow('apiDefinitions')} field is deprecated. Use ${green('apis')} instead, see changelog: <link>\n`
-  //   );
-  // }
-  // if (referenceDocs) {
-  //   process.stderr.write(
-  //     `The ${yellow('referenceDocs')} field is deprecated. Use ${green('features.openapi')} instead, see changelog: <link>\n`
-  //   );
-  // }
+  if (apiDefinitions) {
+    process.stderr.write(
+      `The ${yellow('apiDefinitions')} field is deprecated. Use ${green(
+        'apis',
+      )} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`,
+    );
+  }
+  if (referenceDocs) {
+    process.stderr.write(
+      `The ${yellow('referenceDocs')} field is deprecated. Use ${green(
+        'features.openapi',
+      )} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`,
+    );
+  }
   return {
     'features.openapi': referenceDocs,
     apis: transformApiDefinitionsToApis(apiDefinitions),

package/src/config/minimal.ts

@@ -18,6 +18,7 @@ export default {
     'operation-description': 'off',
     'operation-2xx-response': 'warn',
     'operation-4xx-response': 'off',
+    'assertions': 'warn',
     'operation-operationId': 'warn',
     'operation-summary': 'warn',
     'operation-operationId-unique': 'warn',

package/src/config/recommended.ts

@@ -17,6 +17,7 @@ export default {
     'path-parameters-defined': 'error',
     'operation-description': 'off',
     'operation-2xx-response': 'warn',
+    'assertions': 'warn',
     'operation-4xx-response': 'warn',
     'operation-operationId': 'warn',
     'operation-summary': 'error',

package/src/config/rules.ts

@@ -24,14 +24,23 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
           return undefined;
         }
 
-        const visitor = rule(ruleSettings);
+        const visitors = rule(ruleSettings);
+
+        if (Array.isArray(visitors)) {
+          return visitors.map((visitor: any) => ({
+            severity: ruleSettings.severity,
+            ruleId,
+            visitor: visitor,
+          }))
+        }
 
         return {
           severity: ruleSettings.severity,
           ruleId,
-          visitor,
+          visitor: visitors, // note: actually it is only one visitor object
         };
       }),
     )
+    .flatMap(visitor => visitor)
     .filter(notUndefined);
 }

package/src/lint.ts

@@ -11,7 +11,7 @@ import { LintConfig, Config } from './config/config';
 import { normalizeTypes } from './types';
 import { initRules } from './config/rules';
 import { releaseAjvInstance } from './rules/ajv';
-import { detectOpenAPI, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
+import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
 import { ConfigTypes } from './types/redocly-yaml';
 import { OasSpec } from './rules/common/spec';
 import { defaultPlugin } from './config/builtIn';
@@ -76,8 +76,8 @@ export async function lintDocument(opts: {
   };
 
   const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
-  const regularRules = initRules(rules as any, config, 'rules', oasVersion);
-  const normalizedVisitors = normalizeVisitors([...preprocessors, ...regularRules], types);
+  const regularRules = initRules(rules as Oas3RuleSet[], config, 'rules', oasVersion);
+  const normalizedVisitors = normalizeVisitors([...preprocessors, ...regularRules] as any, types);
   const resolvedRefMap = await resolveDocument({
     rootDocument: document,
     rootType: types.DefinitionRoot,

package/src/ref-utils.ts

@@ -60,7 +60,7 @@ export function pointerBaseName(pointer: string) {
 
 export function refBaseName(ref: string) {
   const parts = ref.split(/[\/\\]/); // split by '\' and '/'
-  return parts[parts.length - 1].split('.')[0];
+  return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
 }
 
 export function isAbsoluteUrl(ref: string) {

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

@@ -0,0 +1,231 @@
+import { asserts } from '../asserts';
+
+describe('oas3 assertions', () => {
+  describe('generic rules', () => {
+    const fakeNode = {
+      foo: '',
+      bar: '',
+      baz: '',
+    };
+
+    describe('pattern', () => {
+      it('value should match regex pattern', () => {
+        expect(asserts.pattern('test string', '/test/')).toBeTruthy();
+        expect(asserts.pattern('test string', '/test me/')).toBeFalsy();
+        expect(asserts.pattern(['test string', 'test me'], '/test/')).toBeTruthy();
+        expect(asserts.pattern(['test string', 'test me'], '/test me/')).toBeFalsy();
+      });
+    });
+
+    describe('enum', () => {
+      it('value should be among predefined keys', () => {
+        expect(asserts.enum('test', ['test', 'example'])).toBeTruthy();
+        expect(asserts.enum(['test'], ['test', 'example'])).toBeTruthy();
+        expect(asserts.enum(['test', 'example'], ['test', 'example'])).toBeTruthy();
+        expect(asserts.enum(['test', 'example', 'foo'], ['test', 'example'])).toBeFalsy();
+        expect(asserts.enum('test', ['foo', 'example'])).toBeFalsy();
+        expect(asserts.enum(['test', 'foo'], ['test', 'example'])).toBeFalsy();
+      });
+    });
+
+    describe('defined', () => {
+      it('value should be defined', () => {
+        expect(asserts.defined('test', true)).toBeTruthy();
+        expect(asserts.defined(undefined, true)).toBeFalsy();
+      });
+      it('value should be undefined', () => {
+        expect(asserts.defined(undefined, false)).toBeTruthy();
+        expect(asserts.defined('test', false)).toBeFalsy();
+      });
+    });
+
+    describe('undefined', () => {
+      it('value should be undefined', () => {
+        expect(asserts.undefined(undefined, true)).toBeTruthy();
+        expect(asserts.undefined('test', true)).toBeFalsy();
+      });
+      it('value should be defined', () => {
+        expect(asserts.undefined('test', false)).toBeTruthy();
+        expect(asserts.undefined(undefined, false)).toBeFalsy();
+      });
+    });
+
+    describe('required', () => {
+      it('values should be required', () => {
+        expect(asserts.required(['one', 'two', 'three'], ['one', 'two'])).toBeTruthy();
+        expect(asserts.required(['one', 'two'], ['one', 'two', 'three'])).toBeFalsy();
+      });
+    });
+
+    describe('nonEmpty', () => {
+      it('value should not be empty', () => {
+        expect(asserts.nonEmpty('test', true)).toBeTruthy();
+        expect(asserts.nonEmpty('', true)).toBeFalsy();
+        expect(asserts.nonEmpty(null, true)).toBeFalsy();
+        expect(asserts.nonEmpty(undefined, true)).toBeFalsy();
+      });
+      it('value should be empty', () => {
+        expect(asserts.nonEmpty('', false)).toBeTruthy();
+        expect(asserts.nonEmpty(null, false)).toBeTruthy();
+        expect(asserts.nonEmpty(undefined, false)).toBeTruthy();
+        expect(asserts.nonEmpty('test', false)).toBeFalsy();
+      });
+    });
+
+    describe('minLength', () => {
+      it('value should have less or equal than 5 symbols length', () => {
+        expect(asserts.minLength('test', 5)).toBeFalsy();
+        expect(asserts.minLength([1, 2, 3, 4], 5)).toBeFalsy();
+        expect(asserts.minLength([1, 2, 3, 4, 5], 5)).toBeTruthy();
+        expect(asserts.minLength([1, 2, 3, 4, 5, 6], 5)).toBeTruthy();
+        expect(asserts.minLength('example', 5)).toBeTruthy();
+        expect(asserts.minLength([], 5)).toBeFalsy();
+        expect(asserts.minLength('', 5)).toBeFalsy();
+      });
+    });
+
+    describe('maxLength', () => {
+      it('value should have more or equal than 5 symbols length', () => {
+        expect(asserts.maxLength('test', 5)).toBeTruthy();
+        expect(asserts.maxLength([1, 2, 3, 4], 5)).toBeTruthy();
+        expect(asserts.maxLength([1, 2, 3, 4, 5], 5)).toBeTruthy();
+        expect(asserts.maxLength([1, 2, 3, 4, 5, 6], 5)).toBeFalsy();
+        expect(asserts.maxLength('example', 5)).toBeFalsy();
+        expect(asserts.maxLength([], 5)).toBeTruthy();
+        expect(asserts.maxLength('', 5)).toBeTruthy();
+      });
+    });
+
+    describe('casing', () => {
+      it('value should be camelCase', () => {
+        expect(asserts.casing(['testExample', 'fooBar'], 'camelCase')).toBeTruthy();
+        expect(asserts.casing(['testExample', 'FooBar'], 'camelCase')).toBeFalsy();
+        expect(asserts.casing('testExample', 'camelCase')).toBeTruthy();
+        expect(asserts.casing('TestExample', 'camelCase')).toBeFalsy();
+        expect(asserts.casing('test-example', 'camelCase')).toBeFalsy();
+        expect(asserts.casing('test_example', 'camelCase')).toBeFalsy();
+      });
+      it('value should be PascalCase', () => {
+        expect(asserts.casing('TestExample', 'PascalCase')).toBeTruthy();
+        expect(asserts.casing(['TestExample', 'FooBar'], 'PascalCase')).toBeTruthy();
+        expect(asserts.casing(['TestExample', 'fooBar'], 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('testExample', 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('test-example', 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('test_example', 'PascalCase')).toBeFalsy();
+      });
+      it('value should be kebab-case', () => {
+        expect(asserts.casing('test-example', 'kebab-case')).toBeTruthy();
+        expect(asserts.casing(['test-example', 'foo-bar'], 'kebab-case')).toBeTruthy();
+        expect(asserts.casing(['test-example', 'foo_bar'], 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('testExample', 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('test_example', 'kebab-case')).toBeFalsy();
+      });
+      it('value should be snake_case', () => {
+        expect(asserts.casing('test_example', 'snake_case')).toBeTruthy();
+        expect(asserts.casing(['test_example', 'foo_bar'], 'snake_case')).toBeTruthy();
+        expect(asserts.casing(['test_example', 'foo-bar'], 'snake_case')).toBeFalsy();
+        expect(asserts.casing('testExample', 'snake_case')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'snake_case')).toBeFalsy();
+        expect(asserts.casing('test-example', 'snake_case')).toBeFalsy();
+      });
+      it('value should be MACRO_CASE', () => {
+        expect(asserts.casing('TEST_EXAMPLE', 'MACRO_CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO_BAR'], 'MACRO_CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO-BAR'], 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST_EXAMPLE_', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('_TEST_EXAMPLE', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST__EXAMPLE', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST-EXAMPLE', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('testExample', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('test-example', 'MACRO_CASE')).toBeFalsy();
+      });
+      it('value should be COBOL-CASE', () => {
+        expect(asserts.casing('TEST-EXAMPLE', 'COBOL-CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO-BAR'], 'COBOL-CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO_BAR'], 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST-EXAMPLE-', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('0TEST-EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('-TEST-EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST--EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST_EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('testExample', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('test-example', 'COBOL-CASE')).toBeFalsy();
+      });
+      it('value should be flatcase', () => {
+        expect(asserts.casing('testexample', 'flatcase')).toBeTruthy();
+        expect(asserts.casing(['testexample', 'foobar'], 'flatcase')).toBeTruthy();
+        expect(asserts.casing(['testexample', 'foo_bar'], 'flatcase')).toBeFalsy();
+        expect(asserts.casing('testexample_', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('0testexample', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('testExample', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('test-example', 'flatcase')).toBeFalsy();
+      });
+    });
+
+    describe.skip('sortOrder', () => {
+      it('value should be ordered in ASC direction', () => {
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'asc')).toBeTruthy();
+        expect(asserts.sortOrder(['example', 'foo', 'test'], { direction: 'asc' })).toBeTruthy();
+        expect(asserts.sortOrder(['example'], 'asc')).toBeTruthy();
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'asc')).toBeFalsy();
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'desc')).toBeFalsy();
+        expect(
+          asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], {
+            direction: 'asc',
+            property: 'name',
+          }),
+        ).toBeTruthy();
+        expect(
+          asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], {
+            direction: 'desc',
+            property: 'name',
+          }),
+        ).toBeFalsy();
+      });
+      it('value should be ordered in DESC direction', () => {
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'desc')).toBeTruthy();
+        expect(asserts.sortOrder(['test', 'foo', 'example'], { direction: 'desc' })).toBeTruthy();
+        expect(asserts.sortOrder(['example'], 'desc')).toBeTruthy();
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'desc')).toBeFalsy();
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'asc')).toBeFalsy();
+        expect(
+          asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], {
+            direction: 'desc',
+            property: 'name',
+          }),
+        ).toBeTruthy();
+        expect(
+          asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], {
+            direction: 'asc',
+            property: 'name',
+          }),
+        ).toBeFalsy();
+      });
+    });
+
+    describe('mutuallyExclusive', () => {
+      it('node should not have more than one property from predefined list', () => {
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'test'])).toBeTruthy();
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), [])).toBeTruthy();
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar'])).toBeFalsy();
+        expect(
+          asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar', 'test']),
+        ).toBeFalsy();
+      });
+    });
+
+    describe('mutuallyRequired', () => {
+      it('node should have all the properties from predefined list', () => {
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar'])).toBeTruthy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'baz'])).toBeTruthy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), [])).toBeTruthy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'test'])).toBeFalsy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'test'])).toBeFalsy();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+import { Assertions } from '../.';
+
+const opts = {
+  '0': {
+    subject: 'Operation',
+    property: 'summary',
+    description: 'example warn text',
+    severity: 'warn',
+    pattern: '/example/',
+  },
+  '1': {
+    subject: 'PathItem',
+    context: [{ type: 'Operation', matchParentKeys: ['post'] }],
+    description: 'example warn text',
+    severity: 'warn',
+    mutuallyExclusive: ['summary', 'security'],
+  },
+  '2': {
+    subject: ['PathItem'],
+    context: [{ type: 'Operation' }],
+    property: 'tags',
+    description: 'example warn text',
+    severity: 'warn',
+    sortOrder: 'desc',
+  },
+  '3': {
+    subject: ['Foo'],
+    context: [{ type: 'Bar' }, { type: 'Baz' }],
+    property: 'test',
+    description: 'example warn text',
+    severity: 'warn',
+    sortOrder: 'desc',
+  },
+};
+
+describe('Oas3 assertions', () => {
+  it('should return the right visitor structure', () => {
+    const visitors = Assertions(opts) as any;
+    expect(visitors).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "Operation": [Function],
+        },
+        Object {
+          "Operation": Object {
+            "PathItem": [Function],
+            "skip": [Function],
+          },
+        },
+        Object {
+          "Operation": Object {
+            "PathItem": [Function],
+          },
+        },
+        Object {
+          "Bar": Object {
+            "Baz": Object {
+              "Foo": [Function],
+            },
+          },
+        },
+      ]
+    `);
+  });
+});

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],
+            },
+          }
+        `);
+      });
+    });
+  });
+});