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

package/src/config/__tests__/fixtures/resolve-config/local-config-with-custom-function.yaml

@@ -3,12 +3,14 @@ lint:
     no-invalid-media-type-examples: warn
     operation-4xx-response: off
     assert/tag-description:
-      subject: Tag
-      property: description
+      subject: 
+        type: Tag
+        property: description
       message: Tag description must have at least 3 words.
       severity: error
-      test-plugin/checkWordsCount:
-        min: 3
+      assertions:
+        test-plugin/checkWordsCount:
+          min: 3
   plugins:
     - plugin.js
   extends:

package/src/config/__tests__/load.test.ts

@@ -49,7 +49,10 @@ describe('loadConfig', () => {
 
   it('should call callback if such passed', async () => {
     const mockFn = jest.fn();
-    await loadConfig({ processRawConfig: mockFn });
+    await loadConfig({
+      configPath: path.join(__dirname, './fixtures/load-redocly.yaml'),
+      processRawConfig: mockFn,
+    });
     expect(mockFn).toHaveBeenCalled();
   });
 });

package/src/config/all.ts

@@ -2,7 +2,6 @@ import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
-    'info-description': 'error',
     'info-contact': 'error',
     'info-license': 'error',
     'info-license-url': 'error',

package/src/config/config-resolvers.ts

@@ -1,5 +1,6 @@
 import * as path from 'path';
 import { isAbsoluteUrl } from '../ref-utils';
+import { pickDefined } from '../utils';
 import { BaseResolver } from '../resolve';
 import { defaultPlugin } from './builtIn';
 import {
@@ -21,10 +22,16 @@ import type {
   DeprecatedInRawConfig,
 } from './types';
 import { isBrowser } from '../env';
-import { isNotString, isString, isDefined, parseYaml } from '../utils';
+import { isNotString, isString, isDefined, parseYaml, keysOf } from '../utils';
 import { Config } from './config';
 import { colorize, logger } from '../logger';
-import { asserts, buildAssertCustomFunction } from '../rules/common/assertions/asserts';
+import {
+  Asserts,
+  AssertionFn,
+  asserts,
+  buildAssertCustomFunction,
+} from '../rules/common/assertions/asserts';
+import type { Assertion, AssertionDefinition, RawAssertion } from '../rules/common/assertions';
 
 export async function resolveConfig(rawConfig: RawConfig, configPath?: string): Promise<Config> {
   if (rawConfig.styleguide?.extends?.some(isNotString)) {
@@ -355,7 +362,7 @@ function getMergedRawStyleguideConfig(
 ) {
   const resultLint = {
     ...rootStyleguideConfig,
-    ...apiStyleguideConfig,
+    ...pickDefined(apiStyleguideConfig),
     rules: { ...rootStyleguideConfig?.rules, ...apiStyleguideConfig?.rules },
     oas2Rules: { ...rootStyleguideConfig?.oas2Rules, ...apiStyleguideConfig?.oas2Rules },
     oas3_0Rules: { ...rootStyleguideConfig?.oas3_0Rules, ...apiStyleguideConfig?.oas3_0Rules },
@@ -408,26 +415,17 @@ function groupStyleguideAssertionRules({
   const transformedRules: Record<string, RuleConfig> = {};
 
   // Collect assertion rules
-  const assertions = [];
+  const assertions: Assertion[] = [];
   for (const [ruleKey, rule] of Object.entries(rules)) {
     if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
-      const assertion = rule;
+      const assertion = rule as RawAssertion;
+
       if (plugins) {
-        for (const field of Object.keys(assertion)) {
-          const [pluginId, fn] = field.split('/');
-          if (!pluginId || !fn) continue;
-          const plugin = plugins.find((plugin) => plugin.id === pluginId);
-          if (!plugin) {
-            throw Error(colorize.red(`Plugin ${colorize.blue(pluginId)} isn't found.`));
-          }
-          if (!plugin.assertions || !plugin.assertions[fn]) {
-            throw Error(
-              `Plugin ${colorize.red(
-                pluginId
-              )} doesn't export assertions function with name ${colorize.red(fn)}.`
-            );
-          }
-          asserts[field] = buildAssertCustomFunction(plugin.assertions[fn]);
+        registerCustomAssertions(plugins, assertion);
+
+        // We may have custom assertion inside where block
+        for (const context of assertion.where || []) {
+          registerCustomAssertions(plugins, context);
         }
       }
       assertions.push({
@@ -445,3 +443,29 @@ function groupStyleguideAssertionRules({
 
   return transformedRules;
 }
+
+function registerCustomAssertions(plugins: Plugin[], assertion: AssertionDefinition) {
+  for (const field of keysOf(assertion.assertions)) {
+    const [pluginId, fn] = field.split('/');
+
+    if (!pluginId || !fn) continue;
+
+    const plugin = plugins.find((plugin) => plugin.id === pluginId);
+
+    if (!plugin) {
+      throw Error(colorize.red(`Plugin ${colorize.blue(pluginId)} isn't found.`));
+    }
+
+    if (!plugin.assertions || !plugin.assertions[fn]) {
+      throw Error(
+        `Plugin ${colorize.red(
+          pluginId
+        )} doesn't export assertions function with name ${colorize.red(fn)}.`
+      );
+    }
+
+    (asserts as Asserts & { [name: string]: AssertionFn })[field] = buildAssertCustomFunction(
+      plugin.assertions[fn]
+    );
+  }
+}

package/src/config/load.ts

@@ -71,11 +71,8 @@ export async function loadConfig(
   } = {}
 ): Promise<Config> {
   const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
-  const config = await getConfig(configPath);
+  const config = await getConfig(configPath, processRawConfig);
   const rawConfig = { ...config, files: files ?? config.files, region: region ?? config.region };
-  if (typeof processRawConfig === 'function') {
-    await processRawConfig(rawConfig);
-  }
 
   const redoclyClient = new RedoclyClient();
   const tokens = await redoclyClient.getTokens();
@@ -105,11 +102,17 @@ export function findConfig(dir?: string): string | undefined {
   return existingConfigFiles[0];
 }
 
-export async function getConfig(configPath: string | undefined = findConfig()): Promise<RawConfig> {
+export async function getConfig(
+  configPath: string | undefined = findConfig(),
+  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>
+): Promise<RawConfig> {
   if (!configPath || !doesYamlFileExist(configPath)) return {};
   try {
     const rawConfig =
       (await loadYaml<RawConfig & DeprecatedInRawConfig & FlatRawConfig>(configPath)) || {};
+    if (typeof processRawConfig === 'function') {
+      await processRawConfig(rawConfig);
+    }
     return transformConfig(rawConfig);
   } catch (e) {
     throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);

package/src/config/minimal.ts

@@ -2,7 +2,6 @@ import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
-    'info-description': 'warn',
     'info-contact': 'off',
     'info-license': 'off',
     'info-license-url': 'off',

package/src/config/recommended.ts

@@ -2,7 +2,6 @@ import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
-    'info-description': 'warn',
     'info-contact': 'off',
     'info-license': 'warn',
     'info-license-url': 'warn',

package/src/rules/common/__tests__/operation-2xx-response.test.ts

@@ -88,4 +88,41 @@ describe('Oas3 operation-2xx-response', () => {
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
   });
+
+  it('should report even if the responses are null', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            '/test/':
+              put:
+                responses: null
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'operation-2xx-response': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1test~1/put/responses",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Operation must have at least one \`2XX\` response.",
+          "ruleId": "operation-2xx-response",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
 });

package/src/rules/common/__tests__/operation-4xx-response.test.ts

@@ -127,4 +127,41 @@ describe('Oas3 operation-4xx-response', () => {
       ]
     `);
   });
+
+  it('should report even if the responses are null', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            '/test/':
+              put:
+                responses: null
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'operation-2xx-response': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1test~1/put/responses",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Operation must have at least one \`2XX\` response.",
+          "ruleId": "operation-2xx-response",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
 });

package/src/rules/common/__tests__/path-params-defined.test.ts

@@ -130,4 +130,73 @@ describe('Oas3 path-params-defined', () => {
       ]
     `);
   });
+
+  it('should fail cause POST has no parameters', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            /pets/{a}:
+              get:
+                parameters:
+                 - name: a
+                   in: path
+              post:
+                description: without parameters
+      `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'path-params-defined': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1pets~1{a}/post/parameters",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The operation does not define the path parameter \`{a}\` expected by path \`/pets/{a}\`.",
+          "ruleId": "path-params-defined",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should apply parameters for POST operation from path parameters', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            /pets/{a}:
+              parameters:
+                - name: a
+                  in: path
+              get:
+                parameters:
+                 - name: a
+                   in: path
+              post:
+                description: without parameters
+      `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'path-params-defined': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
 });

package/src/rules/common/__tests__/security-defined.test.ts

@@ -81,12 +81,12 @@ describe('Oas3 security-defined', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/",
-              "reportOnKey": false,
+              "pointer": "#/paths/~1pets/get",
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],
-          "message": "Every API should have security defined on the root level or for each operation.",
+          "message": "Every operation should have security defined on it or on the root level.",
           "ruleId": "security-defined",
           "severity": "error",
           "suggest": Array [],
@@ -133,12 +133,12 @@ describe('Oas3 security-defined', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/",
-              "reportOnKey": false,
+              "pointer": "#/paths/~1cats/get",
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],
-          "message": "Every API should have security defined on the root level or for each operation.",
+          "message": "Every operation should have security defined on it or on the root level.",
           "ruleId": "security-defined",
           "severity": "error",
           "suggest": Array [],

package/src/rules/common/__tests__/spec.test.ts

@@ -139,3 +139,128 @@ describe('Oas3 spec', () => {
     `);
   });
 });
+
+describe('Oas3.1 spec', () => {
+  it('should report with "type can be one of the following only"', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.1.0
+      info:
+        version: 1.0.0
+        title: Example.com
+        description: info,
+        license:
+          name: Apache 2.0
+          url: 'http://www.apache.org/licenses/LICENSE-2.0.html'
+      components:
+        schemas:
+          TestSchema:
+            title: TestSchema
+            description: Property name's description
+            type: test
+        `
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/components/schemas/TestSchema/type",
+              "reportOnKey": false,
+              "source": "",
+            },
+          ],
+          "message": "\`type\` can be one of the following only: \\"object\\", \\"array\\", \\"string\\", \\"number\\", \\"integer\\", \\"boolean\\", \\"null\\".",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report with unknown type in type`s list', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.1.0
+      info:
+        version: 1.0.0
+        title: Example.com
+        description: info,
+        license:
+          name: Apache 2.0
+          url: 'http://www.apache.org/licenses/LICENSE-2.0.html'
+      components:
+        schemas:
+          TestSchema:
+            title: TestSchema
+            description: Property name's description
+            type:
+              - string
+              - foo
+        `
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/components/schemas/TestSchema/type/1",
+              "reportOnKey": false,
+              "source": "",
+            },
+          ],
+          "message": "\`type\` can be one of the following only: \\"object\\", \\"array\\", \\"string\\", \\"number\\", \\"integer\\", \\"boolean\\", \\"null\\".",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report about unknown type', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.1.0
+      info:
+        version: 1.0.0
+        title: Example.com
+        description: info,
+        license:
+          name: Apache 2.0
+          url: 'http://www.apache.org/licenses/LICENSE-2.0.html'
+      components:
+        schemas:
+          TestSchema:
+            title: TestSchema
+            description: Property name's description
+            type: null
+        `
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});

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

@@ -1,6 +1,6 @@
 import { Location } from '../../../../ref-utils';
 import { Source } from '../../../../resolve';
-import { asserts, buildAssertCustomFunction } from '../asserts';
+import { Asserts, asserts, buildAssertCustomFunction } from '../asserts';
 
 let baseLocation = new Location(jest.fn() as any as Source, 'pointer');
 
@@ -674,9 +674,13 @@ describe('oas3 assertions', () => {
           }
           return [];
         });
-        asserts['local/customFn'] = buildAssertCustomFunction(customFn);
+        asserts['local/customFn' as keyof Asserts] = buildAssertCustomFunction(customFn);
         expect(
-          asserts['local/customFn'](Object.keys(fakeNode), { word: 'foo' }, baseLocation)
+          asserts['local/customFn' as keyof Asserts](
+            Object.keys(fakeNode),
+            { word: 'foo' },
+            baseLocation
+          )
         ).toEqual([
           {
             message: 'First value should be foo',

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

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