@redocly/openapi-core 1.0.0-beta.62 → 1.0.0-beta.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.62",
+  "version": "1.0.0-beta.66",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -30,22 +30,24 @@
     "Andriy Leliv <andriy@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/ajv": "^8.6.2",
+    "@redocly/ajv": "^8.6.4",
     "@types/node": "^14.11.8",
     "colorette": "^1.2.0",
     "js-levenshtein": "^1.1.6",
-    "js-yaml": "^3.14.1",
+    "js-yaml": "^4.1.0",
     "lodash.isequal": "^4.5.0",
     "minimatch": "^3.0.4",
     "node-fetch": "^2.6.1",
+    "pluralize": "^8.0.0",
     "yaml-ast-parser": "0.0.43"
   },
   "devDependencies": {
     "@types/js-levenshtein": "^1.1.0",
-    "@types/js-yaml": "^3.12.4",
+    "@types/js-yaml": "^4.0.3",
     "@types/lodash.isequal": "^4.5.5",
     "@types/minimatch": "^3.0.3",
     "@types/node-fetch": "^2.5.7",
+    "@types/pluralize": "^0.0.29",
     "typescript": "^4.0.5"
   }
 }

package/src/__tests__/js-yaml.test.ts

@@ -0,0 +1,47 @@
+import { parseYaml, stringifyYaml } from '../js-yaml';
+
+const yaml = `
+  emptyValue:
+  spaces in keys: spaces in keys
+  numberString: '0123456789'
+  number: 1000
+  decimal: 12.34
+  boolean: true
+  date: 2020-01-01
+  array:
+    - 1
+    - 2
+  object:
+    key1: 1
+    key2: 2
+`;
+
+const jsObject = {
+  emptyValue: null,
+  'spaces in keys': 'spaces in keys',
+  numberString: '0123456789',
+  number: 1000,
+  decimal: 12.34,
+  boolean: true,
+  date: '2020-01-01',
+  array: [1, 2],
+  object: { key1: 1, key2: 2 },
+};
+
+describe('js-yaml', () => {
+  test('parseYaml', () => {
+    expect(parseYaml(yaml)).toEqual(jsObject);
+  });
+
+  test('parse and stringify', () => {
+    expect(parseYaml(stringifyYaml(jsObject))).toEqual(jsObject);
+  });
+
+  test('should throw an error for unsupported types', () => {
+    expect(() => stringifyYaml({ date: new Date() }))
+      .toThrow('unacceptable kind of an object to dump [object Date]');
+
+    expect(() => stringifyYaml({ foo: () => {} }))
+      .toThrow('unacceptable kind of an object to dump [object Function]');
+  });
+});

package/src/__tests__/lint.test.ts

@@ -87,6 +87,19 @@ describe('lint', () => {
           "severity": "error",
           "suggest": Array [],
         },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/referenceDocs/layout",
+              "reportOnKey": false,
+              "source": "",
+            },
+          ],
+          "message": "Expected type \`string\` but got \`object\`.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
       ]
     `);
   });

package/src/__tests__/utils.test.ts

@@ -0,0 +1,74 @@
+import { pickObjectProps, omitObjectProps, slash } from '../utils';
+
+describe('utils', () => {
+  const testObject = {
+    a: 'value a',
+    b: 'value b',
+    c: 'value c',
+    d: 'value d',
+    e: 'value e',
+  };
+
+  describe('pickObjectProps', () => {
+    it('returns correct object result', () => {
+      expect(pickObjectProps(testObject, ['a', 'b'])).toStrictEqual({ a: 'value a', b: 'value b' });
+    });
+
+    it('returns correct object if passed non existing key', () => {
+      expect(pickObjectProps(testObject, ['a', 'b', 'nonExisting'])).toStrictEqual({
+        a: 'value a',
+        b: 'value b',
+      });
+    });
+
+    it('returns an empty object if no keys are passed', () => {
+      expect(pickObjectProps(testObject, [])).toStrictEqual({});
+    });
+
+    it('returns an empty object if empty target obj passed', () => {
+      expect(pickObjectProps({}, ['d', 'e'])).toStrictEqual({});
+    });
+  });
+
+  describe('omitObjectProps', () => {
+    it('returns correct object result', () => {
+      expect(omitObjectProps(testObject, ['a', 'b', 'c'])).toStrictEqual({
+        d: 'value d',
+        e: 'value e',
+      });
+    });
+
+    it('returns correct object if passed non existing key', () => {
+      expect(omitObjectProps(testObject, ['a', 'b', 'c', 'nonExisting'])).toStrictEqual({
+        d: 'value d',
+        e: 'value e',
+      });
+    });
+
+    it('returns full object if no keys are passed', () => {
+      expect(omitObjectProps(testObject, [])).toStrictEqual(testObject);
+    });
+
+    it('returns an empty object if empty target obj passed', () => {
+      expect(omitObjectProps({}, ['d', 'e'])).toStrictEqual({});
+    });
+  });
+
+  describe('slash path', () => {
+    it('can correctly slash path', () => {
+      [
+        ['foo\\bar', 'foo/bar'],
+        ['foo/bar', 'foo/bar'],
+        ['foo\\中文', 'foo/中文'],
+        ['foo/中文', 'foo/中文'],
+      ].forEach(([path, expectRes]) => {
+        expect(slash(path)).toBe(expectRes);
+      });
+    });
+
+    it('does not modify extended length paths', () => {
+      const extended = '\\\\?\\some\\path';
+      expect(slash(extended)).toBe(extended);
+    });
+  });
+});

package/src/benchmark/utils.ts

@@ -1,4 +1,4 @@
-import * as yaml from 'js-yaml';
+import { parseYaml } from '../js-yaml';
 import { Document, Source } from '../resolve';
 import { Oas3RuleSet } from '../oas-types';
 import { RuleConfig, LintConfig, Plugin } from '../config/config';
@@ -6,7 +6,7 @@ import { RuleConfig, LintConfig, Plugin } from '../config/config';
 export function parseYamlToDocument(body: string, absoluteRef: string = ''): Document {
   return {
     source: new Source(absoluteRef, body),
-    parsed: yaml.safeLoad(body, { filename: absoluteRef }),
+    parsed: parseYaml(body, { filename: absoluteRef }),
   };
 }
 

package/src/config/all.ts

@@ -12,6 +12,7 @@ export default {
     'no-identical-paths': 'error',
     'no-ambiguous-paths': 'error',
     'no-path-trailing-slash': 'error',
+    'path-segment-plural': 'error',
     'path-declaration-must-exist': 'error',
     'path-not-include-query': 'error',
     'path-parameters-defined': 'error',
@@ -29,6 +30,12 @@ export default {
     'no-enum-type-mismatch': 'error',
     'boolean-parameter-prefixes': 'error',
     'paths-kebab-case': 'error',
+    'no-http-verbs-in-paths': 'error',
+    'path-excludes-patterns': {
+      severity: 'error',
+      patterns: [],
+    },
+    'request-mime-type': 'error',
     spec: 'error',
   },
   oas3_0Rules: {
@@ -49,5 +56,5 @@ export default {
     'no-unused-components': 'error',
     'no-undefined-server-variable': 'error',
     'no-servers-empty-enum': 'error',
-  }
+  },
 } as LintRawConfig;

package/src/config/config.ts

@@ -1,10 +1,10 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as yaml from 'js-yaml';
 import { dirname } from 'path';
 import { red, blue } from 'colorette';
 
-import { notUndefined } from '../utils';
+import { parseYaml, stringifyYaml } from '../js-yaml';
+import { notUndefined, slash } from '../utils';
 
 import {
   OasVersion,
@@ -190,7 +190,7 @@ export class LintConfig {
     if (fs.hasOwnProperty('existsSync') && fs.existsSync(ignoreFile)) {
       // TODO: parse errors
       this.ignore =
-        (yaml.safeLoad(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
+        (parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
           string,
           Record<string, Set<string>>
         >) || {};
@@ -211,12 +211,12 @@ export class LintConfig {
     const ignoreFile = path.join(dir, IGNORE_FILE);
     const mapped: Record<string, any> = {};
     for (const absFileName of Object.keys(this.ignore)) {
-      const ignoredRules = (mapped[path.relative(dir, absFileName)] = this.ignore[absFileName]);
+      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] = this.ignore[absFileName]);
       for (const ruleId of Object.keys(ignoredRules)) {
         ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]) as any;
       }
     }
-    fs.writeFileSync(ignoreFile, IGNORE_BANNER + yaml.safeDump(mapped));
+    fs.writeFileSync(ignoreFile, IGNORE_BANNER + stringifyYaml(mapped));
   }
 
   addIgnore(problem: NormalizedProblem) {
@@ -384,6 +384,7 @@ export class Config {
   apiDefinitions: Record<string, string>;
   lint: LintConfig;
   resolve: ResolveConfig;
+  licenseKey?: string;
   constructor(public rawConfig: RawConfig, public configFile?: string) {
     this.apiDefinitions = rawConfig.apiDefinitions || {};
     this.lint = new LintConfig(rawConfig.lint || {}, configFile);

package/src/index.ts

@@ -1,4 +1,4 @@
-export { BundleOutputFormat, readFileFromUrl } from './utils';
+export { BundleOutputFormat, readFileFromUrl, slash } from './utils';
 export { Oas3_1Types } from './types/oas3_1';
 export { Oas3Types } from './types/oas3';
 export { Oas2Types } from './types/oas2';
@@ -29,9 +29,11 @@ export {
   YamlParseError,
   makeDocumentFromString,
 } from './resolve';
+export { parseYaml, stringifyYaml } from './js-yaml';
 export { unescapePointer } from './ref-utils';
 export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
 export { normalizeVisitors } from './visitors';
+
 export {
   WalkContext,
   walkDocument,

package/src/js-yaml/index.ts

@@ -0,0 +1,19 @@
+// TODO: add a type for "types" https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/js-yaml/index.d.ts
+// @ts-ignore
+import { JSON_SCHEMA, types, LoadOptions, DumpOptions, load, dump  } from 'js-yaml';
+
+const DEFAULT_SCHEMA_WITHOUT_TIMESTAMP = JSON_SCHEMA.extend({
+  implicit: [types.merge],
+  explicit: [
+    types.binary,
+    types.omap,
+    types.pairs,
+    types.set,
+  ],
+});
+
+export const parseYaml = (str: string, opts?: LoadOptions): unknown =>
+  load(str, {schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP, ...opts});
+
+export const stringifyYaml = (obj: any, opts?: DumpOptions): string =>
+  dump(obj, {schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP, ...opts});

package/src/oas-types.ts

@@ -34,6 +34,10 @@ export function detectOpenAPI(root: any): OasVersion {
     throw new Error('This doesn’t look like an OpenAPI document.\n');
   }
 
+  if (root.openapi && typeof root.openapi !== 'string') {
+    throw new Error(`Invalid OpenAPI version: should be a string but got "${typeof root.openapi}"`);
+  }
+
   if (root.openapi && root.openapi.startsWith('3.0')) {
     return OasVersion.Version3_0;
   }

package/src/resolve.ts

@@ -1,12 +1,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as url from 'url';
-import * as yaml from 'js-yaml';
+
 import { OasRef } from './typings/openapi';
 import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl } from './ref-utils';
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
 import { NormalizedNodeType, isNamedType } from './types';
-import { readFileFromUrl } from './utils';
+import { readFileFromUrl, parseYaml } from './utils';
 import { ResolveConfig } from './config/config';
 
 export type CollectedRefs = Map<string /* absoluteFilePath */, Document>;
@@ -52,7 +52,7 @@ export class ResolveError extends Error {
   }
 }
 
-const jsYamlErrorLineColRegexp = /at line (\d+), column (\d+):/;
+const jsYamlErrorLineColRegexp = /\((\d+):(\d+)\)$/;
 
 export class YamlParseError extends Error {
   col: number;
@@ -79,7 +79,7 @@ export function makeDocumentFromString(sourceString: string, absoluteRef: string
   try {
     return {
       source,
-      parsed: yaml.safeLoad(sourceString, { filename: absoluteRef }),
+      parsed: parseYaml(sourceString, { filename: absoluteRef }),
     };
   } catch (e) {
     throw new YamlParseError(e, source);
@@ -133,7 +133,7 @@ export class BaseResolver {
     try {
       return {
         source,
-        parsed: yaml.safeLoad(source.body, { filename: source.absoluteRef }),
+        parsed: parseYaml(source.body, { filename: source.absoluteRef }),
       };
     } catch (e) {
       throw new YamlParseError(e, source);

package/src/rules/__tests__/no-unresolved-refs.test.ts

@@ -83,7 +83,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
               },
             },
           ],
-          "message": "Failed to parse: unexpected end of the stream within a single quoted scalar in \\"fixtures/invalid-yaml.yaml\\" at line 2, column 1:",
+          "message": "Failed to parse: unexpected end of the stream within a single quoted scalar in \\"fixtures/invalid-yaml.yaml\\" (2:1)",
           "ruleId": "no-unresolved-refs",
           "severity": "error",
           "suggest": Array [],
@@ -96,7 +96,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
               "source": "foobar.yaml",
             },
           ],
-          "message": "Can't resolve $ref: unexpected end of the stream within a single quoted scalar in \\"fixtures/invalid-yaml.yaml\\" at line 2, column 1:",
+          "message": "Can't resolve $ref: unexpected end of the stream within a single quoted scalar in \\"fixtures/invalid-yaml.yaml\\" (2:1)",
           "ruleId": "no-unresolved-refs",
           "severity": "error",
           "suggest": Array [],

package/src/rules/common/__tests__/info-license.test.ts

@@ -27,7 +27,7 @@ describe('Oas3 info-license', () => {
           "location": Array [
             Object {
               "pointer": "#/info",
-              "reportOnKey": false,
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],

package/src/rules/common/info-description-override.ts

@@ -0,0 +1,24 @@
+import { Oas3Decorator, Oas2Decorator } from '../../visitors';
+import { readFileAsStringSync } from '../../utils';
+import { UserContext } from '../../walk';
+
+export const InfoDescriptionOverride: Oas3Decorator | Oas2Decorator = ({ filePath }) => {
+  return {
+    Info: {
+      leave(info, { report, location }: UserContext) {
+        if (!filePath)
+          throw new Error(
+            `Parameter "filePath" is not provided for "info-description-override" rule`,
+          );
+        try {
+          info.description = readFileAsStringSync(filePath);
+        } catch (e) {
+          report({
+            message: `Failed to read markdown override file for "info.description".\n${e.message}`,
+            location: location.child('description'),
+          });
+        }
+      },
+    },
+  };
+};

package/src/rules/common/info-license-url.ts

@@ -7,6 +7,7 @@ export const InfoLicense: Oas3Rule | Oas2Rule = () => {
       if (!info.license) {
         report({
           message: missingRequiredField('Info', 'license'),
+          location: { reportOnKey: true }
         });
       }
     },

package/src/rules/common/no-http-verbs-in-paths.ts

@@ -0,0 +1,36 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2PathItem } from '../../typings/swagger';
+import { Oas3PathItem } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+import { isPathParameter, splitCamelCaseIntoWords } from '../../utils';
+
+const httpMethods = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+
+export const NoHttpVerbsInPaths: Oas3Rule | Oas2Rule = ({ splitIntoWords }) => {
+  return {
+    PathItem(_path: Oas2PathItem | Oas3PathItem, { key, report, location }: UserContext) {
+      const pathKey = key.toString();
+      if (!pathKey.startsWith('/')) return;
+      const pathSegments = pathKey.split('/');
+
+      for (const pathSegment of pathSegments) {
+        if (!pathSegment || isPathParameter(pathSegment)) continue;
+
+        const isHttpMethodIncluded = (method: string) => {
+          return splitIntoWords
+            ? splitCamelCaseIntoWords(pathSegment).has(method)
+            : pathSegment.toLocaleLowerCase().includes(method);
+        };
+
+        for (const method of httpMethods) {
+          if (isHttpMethodIncluded(method)) {
+            report({
+              message: `path \`${pathKey}\` should not contain http verb ${method}`,
+              location: location.key(),
+            });
+          }
+        }
+      }
+    },
+  };
+};

package/src/rules/common/operation-description-override.ts

@@ -0,0 +1,30 @@
+import { Oas3Decorator, Oas2Decorator } from '../../visitors';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+import { readFileAsStringSync } from '../../utils';
+import { UserContext } from '../../walk';
+
+export const OperationDescriptionOverride: Oas3Decorator | Oas2Decorator = ({ operationIds }) => {
+  return {
+    Operation: {
+      leave(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
+        if (!operation.operationId) return;
+        if (!operationIds)
+          throw new Error(
+            `Parameter "operationIds" is not provided for "operation-description-override" rule`,
+          );
+        const operationId = operation.operationId;
+        if (operationIds[operationId]) {
+          try {
+            operation.description = readFileAsStringSync(operationIds[operationId]);
+          } catch (e) {
+            report({
+              message: `Failed to read markdown override file for operation "${operationId}".\n${e.message}`,
+              location: location.child('operationId').key(),
+            });
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/common/path-excludes-patterns.ts

@@ -0,0 +1,23 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+import { Oas2PathItem } from '../../typings/swagger';
+import { Oas3PathItem } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const PathExcludesPatterns: Oas3Rule | Oas2Rule = ({ patterns }) => {
+  return {
+    PathItem(_path: Oas2PathItem | Oas3PathItem, { report, key, location }: UserContext) {
+      if (!patterns)
+        throw new Error(`Parameter "patterns" is not provided for "path-excludes-patterns" rule`);
+      const pathKey = key.toString();
+      if (pathKey.startsWith('/')) {
+        const matches = patterns.filter((pattern: string) => pathKey.match(pattern));
+        for (const match of matches) {
+          report({
+            message: `path \`${pathKey}\` should not match regex pattern: \`${match}\``,
+            location: location.key(),
+          });
+        }
+      }
+    },
+  };
+};

package/src/rules/common/path-segment-plural.ts

@@ -0,0 +1,31 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { isPathParameter, isSingular } from '../../utils';
+
+export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
+  const { ignoreLastPathSegment, exceptions } = opts;
+  return {
+    PathItem: {
+      leave(_path: any, { report, key, location }: UserContext) {
+        const pathKey = key.toString();
+        if (pathKey.startsWith('/')) {
+          const pathSegments = pathKey.split('/');
+          pathSegments.shift();
+          if (ignoreLastPathSegment && pathSegments.length > 1) {
+            pathSegments.pop();
+          }
+
+          for (const pathSegment of pathSegments) {
+            if (exceptions && exceptions.includes(pathSegment)) continue;
+            if (!isPathParameter(pathSegment) && isSingular(pathSegment)) {
+              report({
+                message: `path segment \`${pathSegment}\` should be plural.`,
+                location: location.key(),
+              });
+            }
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/common/tag-description-override.ts

@@ -0,0 +1,25 @@
+import { Oas3Decorator, Oas2Decorator } from '../../visitors';
+import { readFileAsStringSync } from '../../utils';
+import { UserContext } from '../../walk';
+
+export const TagDescriptionOverride: Oas3Decorator | Oas2Decorator = ({ tagNames }) => {
+  return {
+    Tag: {
+      leave(tag, { report }: UserContext) {
+        if (!tagNames)
+          throw new Error(
+            `Parameter "tagNames" is not provided for "tag-description-override" rule`,
+          );
+        if (tagNames[tag.name]) {
+          try {
+            tag.description = readFileAsStringSync(tagNames[tag.name]);
+          } catch (e) {
+            report({
+              message: `Failed to read markdown override file for tag "${tag.name}".\n${e.message}`,
+            });
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/oas2/index.ts

@@ -29,6 +29,14 @@ import { NoIdenticalPaths } from '../common/no-identical-paths';
 import { OperationOperationId } from '../common/operation-operationId';
 import { OperationSummary } from '../common/operation-summary';
 import { NoAmbiguousPaths } from '../common/no-ambiguous-paths';
+import { NoHttpVerbsInPaths } from '../common/no-http-verbs-in-paths';
+import { PathExcludesPatterns } from '../common/path-excludes-patterns';
+import { RequestMimeType } from './request-mime-type';
+import { ResponseMimeType } from './response-mime-type';
+import { PathSegmentPlural } from '../common/path-segment-plural';
+import { OperationDescriptionOverride } from '../common/operation-description-override';
+import { TagDescriptionOverride } from '../common/tag-description-override';
+import { InfoDescriptionOverride } from '../common/info-description-override';
 
 export const rules = {
   spec: OasSpec as Oas2Rule,
@@ -61,9 +69,17 @@ export const rules = {
   'no-identical-paths': NoIdenticalPaths as Oas2Rule,
   'no-ambiguous-paths': NoAmbiguousPaths as Oas2Rule,
   'path-http-verbs-order': PathHttpVerbsOrder as Oas2Rule,
+  'no-http-verbs-in-paths': NoHttpVerbsInPaths as Oas2Rule,
+  'path-excludes-patterns': PathExcludesPatterns as Oas2Rule,
+  'request-mime-type': RequestMimeType as Oas2Rule,
+  'response-mime-type': ResponseMimeType as Oas2Rule,
+  'path-segment-plural': PathSegmentPlural as Oas2Rule,
 };
 
 export const preprocessors = {};
 export const decorators = {
   'registry-dependencies': RegistryDependencies as Oas2Decorator,
+  'operation-description-override': OperationDescriptionOverride as Oas2Decorator,
+  'tag-description-override': TagDescriptionOverride as Oas2Decorator,
+  'info-description-override': InfoDescriptionOverride as Oas2Decorator,
 };

package/src/rules/oas2/request-mime-type.ts

@@ -0,0 +1,17 @@
+import { Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { Oas2Definition, Oas2Operation } from '../../typings/swagger';
+import { validateMimeType } from '../../utils';
+
+export const RequestMimeType: Oas2Rule = ({ allowedValues }) => {
+  return {
+    DefinitionRoot(root: Oas2Definition, ctx: UserContext) {
+      validateMimeType({ type: 'consumes', value: root }, ctx, allowedValues);
+    },
+    Operation: {
+      leave(operation: Oas2Operation, ctx: UserContext) {
+        validateMimeType({ type: 'consumes', value: operation }, ctx, allowedValues);
+      },
+    },
+  };
+};

package/src/rules/oas2/response-mime-type.ts

@@ -0,0 +1,17 @@
+import { Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { Oas2Definition, Oas2Operation } from '../../typings/swagger';
+import { validateMimeType } from '../../utils';
+
+export const ResponseMimeType: Oas2Rule = ({ allowedValues }) => {
+  return {
+    DefinitionRoot(root: Oas2Definition, ctx: UserContext) {
+      validateMimeType({ type: 'produces', value: root }, ctx, allowedValues);
+    },
+    Operation: {
+      leave(operation: Oas2Operation, ctx: UserContext) {
+        validateMimeType({ type: 'produces', value: operation }, ctx, allowedValues);
+      },
+    },
+  };
+};