@redocly/openapi-core 1.0.0-beta.109 → 1.0.0-beta.111

package/src/__tests__/utils.test.ts

@@ -4,6 +4,7 @@ import {
   slash,
   getMatchingStatusCodeRange,
   doesYamlFileExist,
+  pickDefined,
 } from '../utils';
 import { isBrowser } from '../env';
 import * as fs from 'fs';
@@ -81,6 +82,16 @@ describe('utils', () => {
     });
   });
 
+  describe('pickDefined', () => {
+    it('returns undefined for undefined', () => {
+      expect(pickDefined(undefined)).toBeUndefined();
+    });
+
+    it('picks only defined values', () => {
+      expect(pickDefined({ a: 1, b: undefined, c: 3 })).toStrictEqual({ a: 1, c: 3 });
+    });
+  });
+
   describe('getMatchingStatusCodeRange', () => {
     it('should get the generalized form of status codes', () => {
       expect(getMatchingStatusCodeRange('202')).toEqual('2XX');

package/src/__tests__/walk.test.ts

@@ -1115,7 +1115,7 @@ describe('walk order', () => {
     expect(calls).toMatchInlineSnapshot(`
       Array [
         "enter Root",
-        "enter PathsMap",
+        "enter Paths",
         "enter PathItem",
         "enter ParameterList",
         "enter Parameter",
@@ -1134,7 +1134,7 @@ describe('walk order', () => {
         "leave ParameterList",
         "leave Operation",
         "leave PathItem",
-        "leave PathsMap",
+        "leave Paths",
         "enter Components",
         "enter NamedParameters",
         "leave NamedParameters",

package/src/config/__tests__/config-resolvers.test.ts

@@ -1,3 +1,5 @@
+import { colorize } from '../../logger';
+import { asserts } from '../../rules/common/assertions/asserts';
 import { resolveStyleguideConfig, resolveApis, resolveConfig } from '../config-resolvers';
 const path = require('path');
 
@@ -130,6 +132,40 @@ describe('resolveStyleguideConfig', () => {
     expect(styleguide).toMatchSnapshot();
   });
 
+  it('should resolve custom assertion from plugin', async () => {
+    const styleguideConfig = {
+      extends: ['local-config-with-custom-function.yaml'],
+    };
+    const { plugins } = await resolveStyleguideConfig({
+      styleguideConfig,
+      configPath,
+    });
+
+    expect(plugins).toBeDefined();
+    expect(plugins?.length).toBe(2);
+    expect(asserts['test-plugin/checkWordsCount']).toBeDefined();
+  });
+
+  it('should throw error when custom assertion load not exist plugin', async () => {
+    const styleguideConfig = {
+      extends: ['local-config-with-wrong-custom-function.yaml'],
+    };
+    try {
+      await resolveStyleguideConfig({
+        styleguideConfig,
+        configPath,
+      });
+    } catch (e) {
+      expect(e.message.toString()).toContain(
+        `Plugin ${colorize.red(
+          'test-plugin'
+        )} doesn't export assertions function with name ${colorize.red('checkWordsCount2')}.`
+      );
+    }
+
+    expect(asserts['test-plugin/checkWordsCount']).toBeDefined();
+  });
+
   it('should correctly merge assertions from nested config', async () => {
     const styleguideConfig = {
       extends: ['local-config-with-file.yaml'],
@@ -165,7 +201,7 @@ describe('resolveStyleguideConfig', () => {
     const styleguideConfig = {
       // This points to ./fixtures/resolve-remote-configs/remote-config.yaml
       extends: [
-        'https://raw.githubusercontent.com/Redocly/redocly-cli/master/packages/core/src/config/__tests__/fixtures/resolve-remote-configs/remote-config.yaml',
+        'https://raw.githubusercontent.com/Redocly/redocly-cli/main/packages/core/src/config/__tests__/fixtures/resolve-remote-configs/remote-config.yaml',
       ],
     };
 
@@ -428,4 +464,29 @@ describe('resolveConfig', () => {
     delete apis['petstore'].styleguide.pluginPaths;
     expect(apis['petstore'].styleguide).toMatchSnapshot();
   });
+
+  it('should default to the extends from the main config if no extends defined', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          styleguide: {
+            rules: {
+              'operation-4xx-response': 'error',
+            },
+          },
+        },
+      },
+      styleguide: {
+        extends: ['minimal'],
+        rules: {
+          'operation-2xx-response': 'warn',
+        },
+      },
+    };
+
+    const { apis } = await resolveConfig(rawConfig, configPath);
+    expect(apis['petstore'].styleguide.rules).toBeDefined();
+    expect(apis['petstore'].styleguide.rules?.['operation-2xx-response']).toEqual('warn'); // from minimal ruleset
+  });
 });

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

@@ -48,6 +48,7 @@ const testConfig: Config = {
   'features.mockServer': {},
   resolve: { http: { headers: [] } },
   organization: 'redocly-test',
+  files: [],
 };
 
 describe('getMergedConfig', () => {
@@ -67,6 +68,7 @@ describe('getMergedConfig', () => {
         "configFile": "redocly.yaml",
         "features.mockServer": Object {},
         "features.openapi": Object {},
+        "files": Array [],
         "organization": "redocly-test",
         "rawConfig": Object {
           "apis": Object {
@@ -81,6 +83,7 @@ describe('getMergedConfig', () => {
           },
           "features.mockServer": Object {},
           "features.openapi": Object {},
+          "files": Array [],
           "organization": "redocly-test",
           "styleguide": Object {
             "extendPaths": Array [],
@@ -163,6 +166,7 @@ describe('getMergedConfig', () => {
         "configFile": "redocly.yaml",
         "features.mockServer": Object {},
         "features.openapi": Object {},
+        "files": Array [],
         "organization": "redocly-test",
         "rawConfig": Object {
           "apis": Object {
@@ -177,6 +181,7 @@ describe('getMergedConfig', () => {
           },
           "features.mockServer": Object {},
           "features.openapi": Object {},
+          "files": Array [],
           "organization": "redocly-test",
           "styleguide": Object {
             "extendPaths": Array [],

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

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

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

@@ -0,0 +1,16 @@
+lint:
+  rules:
+    no-invalid-media-type-examples: warn
+    operation-4xx-response: off
+    assert/tag-description:
+      subject: Tag
+      property: description
+      message: Tag description must have at least 3 words.
+      severity: error
+      test-plugin/checkWordsCount2:
+        min: 3
+  plugins:
+    - plugin.js
+  extends:
+    - recommended
+    - test-plugin/all

package/src/config/__tests__/fixtures/resolve-config/plugin.js

@@ -51,6 +51,16 @@ const decorators = {
   },
 };
 
+const assertions = {
+  checkWordsCount: (value, opts, location) => {
+    const words = value.split(' ');
+    if (words.length >= opts.min) {
+      return { isValid: true };
+    }
+    return { isValid: false, location };
+  },
+};
+
 const configs = {
   all: {
     rules: {
@@ -66,4 +76,5 @@ module.exports = {
   rules,
   decorators,
   configs,
+  assertions,
 };

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

@@ -49,7 +49,7 @@ describe('loadConfig', () => {
 
   it('should call callback if such passed', async () => {
     const mockFn = jest.fn();
-    await loadConfig(undefined, undefined, mockFn);
+    await loadConfig({ processRawConfig: mockFn });
     expect(mockFn).toHaveBeenCalled();
   });
 });

package/src/config/__tests__/resolve-plugins.test.ts

@@ -5,21 +5,21 @@ describe('resolving a plugin', () => {
   const configPath = path.join(__dirname, 'fixtures/plugin-config.yaml');
 
   it('should prefix rule names with the plugin id', async () => {
-    const config = await loadConfig(configPath);
+    const config = await loadConfig({ configPath });
     const plugin = config.styleguide.plugins[0];
 
     expect(plugin.rules?.oas3).toHaveProperty('test-plugin/openid-connect-url-well-known');
   });
 
   it('should prefix preprocessor names with the plugin id', async () => {
-    const config = await loadConfig(configPath);
+    const config = await loadConfig({ configPath });
     const plugin = config.styleguide.plugins[0];
 
     expect(plugin.preprocessors?.oas2).toHaveProperty('test-plugin/description-preprocessor');
   });
 
   it('should prefix decorator names with the plugin id', async () => {
-    const config = await loadConfig(configPath);
+    const config = await loadConfig({ configPath });
     const plugin = config.styleguide.plugins[0];
 
     expect(plugin.decorators?.oas3).toHaveProperty('test-plugin/inject-x-stats');

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 {
@@ -24,6 +25,7 @@ import { isBrowser } from '../env';
 import { isNotString, isString, isDefined, parseYaml } from '../utils';
 import { Config } from './config';
 import { colorize, logger } from '../logger';
+import { asserts, buildAssertCustomFunction } from '../rules/common/assertions/asserts';
 
 export async function resolveConfig(rawConfig: RawConfig, configPath?: string): Promise<Config> {
   if (rawConfig.styleguide?.extends?.some(isNotString)) {
@@ -175,6 +177,10 @@ export function resolvePlugins(
         }
       }
 
+      if (pluginModule.assertions) {
+        plugin.assertions = pluginModule.assertions;
+      }
+
       return plugin;
     })
     .filter(isDefined);
@@ -299,8 +305,7 @@ export async function resolveStyleguideConfig(
   return {
     ...resolvedStyleguideConfig,
     rules:
-      resolvedStyleguideConfig.rules &&
-      groupStyleguideAssertionRules(resolvedStyleguideConfig.rules),
+      resolvedStyleguideConfig.rules && groupStyleguideAssertionRules(resolvedStyleguideConfig),
   };
 }
 
@@ -351,7 +356,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 },
@@ -392,9 +397,10 @@ function getMergedRawStyleguideConfig(
   return resultLint;
 }
 
-function groupStyleguideAssertionRules(
-  rules: Record<string, RuleConfig> | undefined
-): Record<string, RuleConfig> | undefined {
+function groupStyleguideAssertionRules({
+  rules,
+  plugins,
+}: ResolvedStyleguideConfig): Record<string, RuleConfig> | undefined {
   if (!rules) {
     return rules;
   }
@@ -407,6 +413,24 @@ function groupStyleguideAssertionRules(
   for (const [ruleKey, rule] of Object.entries(rules)) {
     if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
       const assertion = rule;
+      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]);
+        }
+      }
       assertions.push({
         ...assertion,
         assertionId: ruleKey.replace('assert/', ''),

package/src/config/config.ts

@@ -306,6 +306,7 @@ export class Config {
   'features.openapi': Record<string, any>;
   'features.mockServer'?: Record<string, any>;
   organization?: string;
+  files: string[];
   constructor(public rawConfig: ResolvedConfig, public configFile?: string) {
     this.apis = rawConfig.apis || {};
     this.styleguide = new StyleguideConfig(rawConfig.styleguide || {}, configFile);
@@ -314,5 +315,6 @@ export class Config {
     this.resolve = getResolveConfig(rawConfig?.resolve);
     this.region = rawConfig.region;
     this.organization = rawConfig.organization;
+    this.files = rawConfig.files || [];
   }
 }

package/src/config/load.ts

@@ -62,11 +62,17 @@ async function addConfigMetadata({
 }
 
 export async function loadConfig(
-  configPath: string | undefined = findConfig(),
-  customExtends?: string[],
-  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>
+  options: {
+    configPath?: string;
+    customExtends?: string[];
+    processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>;
+    files?: string[];
+    region?: Region;
+  } = {}
 ): Promise<Config> {
-  const rawConfig = await getConfig(configPath);
+  const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
+  const config = await getConfig(configPath);
+  const rawConfig = { ...config, files: files ?? config.files, region: region ?? config.region };
   if (typeof processRawConfig === 'function') {
     await processRawConfig(rawConfig);
   }

package/src/config/types.ts

@@ -10,6 +10,7 @@ import type {
   OasVersion,
 } from '../oas-types';
 import type { NodeType } from '../types';
+import { Location } from '../ref-utils';
 
 export type RuleSeverity = ProblemSeverity | 'off';
 
@@ -83,6 +84,15 @@ export type CustomRulesConfig = {
   oas2?: Oas2RuleSet;
 };
 
+export type AssertResult = { message?: string; location?: Location };
+export type CustomFunction = (
+  value: any,
+  options: unknown,
+  baseLocation: Location
+) => AssertResult[];
+
+export type AssertionsConfig = Record<string, CustomFunction>;
+
 export type Plugin = {
   id: string;
   configs?: Record<string, PluginStyleguideConfig>;
@@ -90,6 +100,7 @@ export type Plugin = {
   preprocessors?: PreprocessorsConfig;
   decorators?: DecoratorsConfig;
   typeExtension?: TypeExtensionsConfig;
+  assertions?: AssertionsConfig;
 };
 
 export type PluginStyleguideConfig = Omit<StyleguideRawConfig, 'plugins' | 'extends'>;
@@ -145,6 +156,7 @@ export type DeprecatedInApi = {
 
 export type ResolvedApi = Omit<Api, 'styleguide'> & {
   styleguide: ResolvedStyleguideConfig;
+  files?: string[];
 };
 
 export type RawConfig = {
@@ -153,6 +165,7 @@ export type RawConfig = {
   resolve?: RawResolveConfig;
   region?: Region;
   organization?: string;
+  files?: string[];
 } & FeaturesConfig;
 
 export type FlatApi = Omit<Api, 'styleguide'> &

package/src/config/utils.ts

@@ -233,6 +233,7 @@ export function getMergedConfig(config: Config, apiName?: string): Config {
             ...config['features.mockServer'],
             ...config.apis[apiName]?.['features.mockServer'],
           },
+          files: [...config.files, ...(config.apis?.[apiName]?.files ?? [])],
           // TODO: merge everything else here
         },
         config.configFile

package/src/rules/ajv.ts

@@ -1,4 +1,4 @@
-import Ajv, { ValidateFunction, ErrorObject } from '@redocly/ajv';
+import Ajv, { ValidateFunction, ErrorObject } from '@redocly/ajv/dist/2020';
 import { Location, escapePointer } from '../ref-utils';
 import { ResolveFn } from '../walk';
 
@@ -20,7 +20,7 @@ function getAjv(resolve: ResolveFn, allowAdditionalProperties: boolean) {
       discriminator: true,
       allowUnionTypes: true,
       validateFormats: false, // TODO: fix it
-      defaultAdditionalProperties: allowAdditionalProperties,
+      defaultUnevaluatedProperties: allowAdditionalProperties,
       loadSchemaSync(base: string, $ref: string) {
         const resolvedRef = resolve({ $ref }, base.split('#')[0]);
         if (!resolvedRef || !resolvedRef.location) return false;
@@ -87,8 +87,8 @@ export function validateJsonSchema(
     if (propName) {
       message = `\`${propName}\` property ${message}`;
     }
-    if (error.keyword === 'additionalProperties') {
-      const property = error.params.additionalProperty;
+    if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
+      const property = error.params.additionalProperty || error.params.unevaluatedProperty;
       message = `${message} \`${property}\``;
       error.instancePath += '/' + escapePointer(property);
     }

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