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

package/lib/types/redocly-yaml.js

@@ -68,7 +68,7 @@ const nodeTypesList = [
     'Info',
     'Contact',
     'License',
-    'PathsMap',
+    'Paths',
     'PathItem',
     'Parameter',
     'Operation',
@@ -80,10 +80,10 @@ const nodeTypesList = [
     'Example',
     'ExamplesMap',
     'Encoding',
-    'EncodingsMap',
+    'EncodingMap',
     'Header',
     'HeadersMap',
-    'ResponsesMap',
+    'Responses',
     'Response',
     'Link',
     'LinksMap',
@@ -106,7 +106,7 @@ const nodeTypesList = [
     'PasswordFlow',
     'ClientCredentials',
     'AuthorizationCode',
-    'SecuritySchemeFlows',
+    'OAuth2Flows',
     'SecurityScheme',
     'XCodeSample',
     'WebhooksMap',
@@ -758,6 +758,16 @@ const ConfigReferenceDocs = {
         unstable_externalDescription: { type: 'boolean' },
         unstable_ignoreMimeParameters: { type: 'boolean' },
         untrustedDefinition: { type: 'boolean' },
+        mockServer: {
+            properties: {
+                url: { type: 'string' },
+                position: { enum: ['first', 'last', 'replace', 'off'] },
+                description: { type: 'string' },
+            },
+        },
+        showAccessMode: { type: 'boolean' },
+        preserveOriginalExtensionsName: { type: 'boolean' },
+        markdownHeadingsAnchorLevel: { type: 'number' },
     },
     additionalProperties: { type: 'string' },
 };

package/lib/utils.d.ts

@@ -46,3 +46,4 @@ export declare function showErrorForDeprecatedField(deprecatedField: string, upd
 export declare type Falsy = undefined | null | false | '' | 0;
 export declare function isTruthy<Truthy>(value: Truthy | Falsy): value is Truthy;
 export declare function identity<T>(value: T): T;
+export declare function pickDefined<T extends Record<string, unknown>>(obj?: T): Record<string, unknown> | undefined;

package/lib/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identity = exports.isTruthy = exports.showErrorForDeprecatedField = exports.showWarningForDeprecatedField = exports.doesYamlFileExist = exports.isCustomRuleId = exports.getMatchingStatusCodeRange = exports.assignExisting = exports.isNotString = exports.isString = exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.isDefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.pickDefined = exports.identity = exports.isTruthy = exports.showErrorForDeprecatedField = exports.showWarningForDeprecatedField = exports.doesYamlFileExist = exports.isCustomRuleId = exports.getMatchingStatusCodeRange = exports.assignExisting = exports.isNotString = exports.isString = exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.isDefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const path_1 = require("path");
 const minimatch = require("minimatch");
@@ -205,3 +205,15 @@ function identity(value) {
     return value;
 }
 exports.identity = identity;
+function pickDefined(obj) {
+    if (!obj)
+        return undefined;
+    const res = {};
+    for (const key in obj) {
+        if (obj[key] !== undefined) {
+            res[key] = obj[key];
+        }
+    }
+    return res;
+}
+exports.pickDefined = pickDefined;

package/lib/visitors.d.ts

@@ -70,9 +70,10 @@ declare type Oas3FlatVisitor = {
     Info?: VisitFunctionOrObject<Oas3Info>;
     Contact?: VisitFunctionOrObject<Oas3Contact>;
     License?: VisitFunctionOrObject<Oas3License>;
-    PathsMap?: VisitFunctionOrObject<Record<string, Oas3PathItem>>;
+    Paths?: VisitFunctionOrObject<Record<string, Oas3PathItem>>;
     PathItem?: VisitFunctionOrObject<Oas3PathItem>;
-    Callback?: VisitFunctionOrObject<Record<string, Oas3PathItem>>;
+    Callback?: VisitFunctionOrObject<Oas3Callback>;
+    CallbacksMap?: VisitFunctionOrObject<Record<string, Oas3Callback>>;
     Parameter?: VisitFunctionOrObject<Oas3Parameter>;
     Operation?: VisitFunctionOrObject<Oas3Operation>;
     RequestBody?: VisitFunctionOrObject<Oas3RequestBody>;
@@ -81,7 +82,7 @@ declare type Oas3FlatVisitor = {
     Example?: VisitFunctionOrObject<Oas3Example>;
     Encoding?: VisitFunctionOrObject<Oas3Encoding>;
     Header?: VisitFunctionOrObject<Oas3Header>;
-    ResponsesMap?: VisitFunctionOrObject<Record<string, Oas3Response>>;
+    Responses?: VisitFunctionOrObject<Record<string, Oas3Response>>;
     Response?: VisitFunctionOrObject<Oas3Response>;
     Link?: VisitFunctionOrObject<Oas3Link>;
     Schema?: VisitFunctionOrObject<Oas3Schema>;
@@ -103,7 +104,7 @@ declare type Oas3FlatVisitor = {
     PasswordFlow?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['password']>;
     ClientCredentials?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['clientCredentials']>;
     AuthorizationCode?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['authorizationCode']>;
-    SecuritySchemeFlows?: VisitFunctionOrObject<Oas3SecurityScheme['flows']>;
+    OAuth2Flows?: VisitFunctionOrObject<Oas3SecurityScheme['flows']>;
     SecurityScheme?: VisitFunctionOrObject<Oas3SecurityScheme>;
 };
 declare type Oas2FlatVisitor = {
@@ -114,13 +115,13 @@ declare type Oas2FlatVisitor = {
     Info?: VisitFunctionOrObject<Oas2Info>;
     Contact?: VisitFunctionOrObject<Oas2Contact>;
     License?: VisitFunctionOrObject<Oas2License>;
-    PathsMap?: VisitFunctionOrObject<Record<string, Oas2PathItem>>;
+    Paths?: VisitFunctionOrObject<Record<string, Oas2PathItem>>;
     PathItem?: VisitFunctionOrObject<Oas2PathItem>;
     Parameter?: VisitFunctionOrObject<any>;
     Operation?: VisitFunctionOrObject<Oas2Operation>;
     Examples?: VisitFunctionOrObject<Record<string, any>>;
     Header?: VisitFunctionOrObject<Oas2Header>;
-    ResponsesMap?: VisitFunctionOrObject<Record<string, Oas2Response>>;
+    Responses?: VisitFunctionOrObject<Record<string, Oas2Response>>;
     Response?: VisitFunctionOrObject<Oas2Response>;
     Schema?: VisitFunctionOrObject<Oas2Schema>;
     Xml?: VisitFunctionOrObject<Oas2Xml>;

package/lib/visitors.js

@@ -4,13 +4,14 @@ exports.normalizeVisitors = void 0;
 const legacyTypesMap = {
     Root: 'DefinitionRoot',
     ServerVariablesMap: 'ServerVariableMap',
-    PathsMap: 'PathMap',
+    Paths: ['PathMap', 'PathsMap'],
     CallbacksMap: 'CallbackMap',
     MediaTypesMap: 'MediaTypeMap',
     ExamplesMap: 'ExampleMap',
-    EncodingsMap: 'EncodingMap',
+    EncodingMap: 'EncodingsMap',
     HeadersMap: 'HeaderMap',
     LinksMap: 'LinkMap',
+    OAuth2Flows: 'SecuritySchemeFlows',
 };
 function normalizeVisitors(visitorsConfig, types) {
     const normalizedVisitors = {};
@@ -85,6 +86,13 @@ function normalizeVisitors(visitorsConfig, types) {
             }
         }
     }
+    function findLegacyVisitorNode(visitor, typeName) {
+        if (Array.isArray(typeName)) {
+            const name = typeName.find((name) => visitor[name]) || undefined;
+            return name && visitor[name];
+        }
+        return visitor[typeName];
+    }
     function normalizeVisitorLevel(ruleConf, visitor, parentContext, depth = 0) {
         const visitorKeys = Object.keys(types);
         if (depth === 0) {
@@ -101,7 +109,7 @@ function normalizeVisitors(visitorsConfig, types) {
         }
         for (const typeName of visitorKeys) {
             const typeVisitor = (visitor[typeName] ||
-                visitor[legacyTypesMap[typeName]]);
+                findLegacyVisitorNode(visitor, legacyTypesMap[typeName]));
             const normalizedTypeVisitor = normalizedVisitors[typeName];
             if (!typeVisitor)
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.110",
+  "version": "1.0.0-beta.111",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/__tests__/__snapshots__/bundle.test.ts.snap

@@ -94,7 +94,7 @@ rootType:
       name: ExternalDocs
     paths:
       properties: {}
-      name: PathsMap
+      name: Paths
     components:
       properties:
         parameters:

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

@@ -464,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/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 {
@@ -355,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 },

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__/utils.test.ts

@@ -65,7 +65,7 @@ describe('Oas3 assertions', () => {
             matchParentKeys: ['put'],
           },
           {
-            type: 'ResponsesMap',
+            type: 'Responses',
             matchParentKeys: [201, 200],
           },
         ];
@@ -75,7 +75,7 @@ describe('Oas3 assertions', () => {
         expect(visitors).toMatchInlineSnapshot(`
           Object {
             "Operation": Object {
-              "ResponsesMap": Object {
+              "Responses": Object {
                 "MediaTypesMap": [Function],
                 "skip": [Function],
               },

package/src/rules/common/no-ambiguous-paths.ts

@@ -5,7 +5,7 @@ import { Oas2Paths } from '../../typings/swagger';
 
 export const NoAmbiguousPaths: Oas3Rule | Oas2Rule = () => {
   return {
-    PathsMap(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
+    Paths(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
       const seenPaths: string[] = [];
 
       for (const currentPath of Object.keys(pathMap)) {

package/src/rules/common/no-identical-paths.ts

@@ -5,18 +5,18 @@ import { Oas2Paths } from '../../typings/swagger';
 
 export const NoIdenticalPaths: Oas3Rule | Oas2Rule = () => {
   return {
-    PathsMap(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
-      const pathsMap = new Map<string, string>();
+    Paths(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
+      const Paths = new Map<string, string>();
       for (const pathName of Object.keys(pathMap)) {
         const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
-        const existingSamePath = pathsMap.get(id);
+        const existingSamePath = Paths.get(id);
         if (existingSamePath) {
           report({
             message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
             location: location.child([pathName]).key(),
           });
         } else {
-          pathsMap.set(id, pathName);
+          Paths.set(id, pathName);
         }
       }
     },

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

@@ -3,8 +3,8 @@ import { UserContext } from '../../walk';
 
 export const Operation2xxResponse: Oas3Rule | Oas2Rule = () => {
   return {
-    ResponsesMap(responses: Record<string, object>, { report }: UserContext) {
-      const codes = Object.keys(responses);
+    Responses(responses: Record<string, object>, { report }: UserContext) {
+      const codes = Object.keys(responses || {});
       if (!codes.some((code) => code === 'default' || /2[Xx0-9]{2}/.test(code))) {
         report({
           message: 'Operation must have at least one `2XX` response.',