@redocly/openapi-core 1.0.0-beta.65 → 1.0.0-beta.69

package/lib/redocly/index.js

@@ -9,16 +9,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedoclyClient = void 0;
+exports.isRedoclyRegistryURL = exports.RedoclyClient = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
 const colorette_1 = require("colorette");
-const query_1 = require("./query");
+const registry_api_1 = require("./registry-api");
 const TOKEN_FILENAME = '.redocly-config.json';
 class RedoclyClient {
     constructor() {
         this.loadToken();
+        this.registryApi = new registry_api_1.RegistryApi(this.accessToken);
     }
     hasToken() {
         return !!this.accessToken;
@@ -43,10 +44,7 @@ class RedoclyClient {
         return __awaiter(this, void 0, void 0, function* () {
             if (!accessToken)
                 return false;
-            const authDetails = yield RedoclyClient.authorize(accessToken, { verbose });
-            if (!authDetails)
-                return false;
-            return true;
+            return this.registryApi.setAccessToken(accessToken).authStatus(verbose);
         });
     }
     getAuthorizationHeader() {
@@ -83,185 +81,20 @@ class RedoclyClient {
         }
         process.stdout.write('Logged out from the Redocly account. ✋\n');
     }
-    query(queryString, parameters = {}, headers = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return query_1.query(queryString, parameters, Object.assign({ Authorization: this.accessToken }, headers));
-        });
-    }
-    static authorize(accessToken, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { queryName = '', verbose = false } = options;
-            try {
-                const queryStr = `query ${queryName}{ viewer { id } }`;
-                return yield query_1.query(queryStr, {}, { Authorization: accessToken });
-            }
-            catch (e) {
-                if (verbose)
-                    console.log(e);
-                return null;
-            }
-        });
-    }
-    updateDependencies(dependencies) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const definitionId = process.env.DEFINITION;
-            const versionId = process.env.DEFINITION;
-            const branchId = process.env.BRANCH;
-            if (!definitionId || !versionId || !branchId)
-                return;
-            yield this.query(`
-    mutation UpdateBranchDependenciesFromURLs(
-      $urls: [String!]!
-      $definitionId: Int!
-      $versionId: Int!
-      $branchId: Int!
-    ) {
-      updateBranchDependenciesFromURLs(
-        definitionId: $definitionId
-        versionId: $versionId
-        branchId: $branchId
-        urls: $urls
-      ) {
-        branchName
-      }
-    }
-    `, {
-                urls: dependencies || [],
-                definitionId: parseInt(definitionId, 10),
-                versionId: parseInt(versionId, 10),
-                branchId: parseInt(branchId, 10),
-            });
-        });
-    }
-    updateDefinitionVersion(definitionId, versionId, updatePatch) {
-        return this.query(`
-      mutation UpdateDefinitionVersion($definitionId: Int!, $versionId: Int!, $updatePatch: DefinitionVersionPatch!) {
-        updateDefinitionVersionByDefinitionIdAndId(input: {definitionId: $definitionId, id: $versionId, patch: $updatePatch}) {
-          definitionVersion {
-            ...VersionDetails
-            __typename
-          }
-          __typename
-        }
-      }
-
-      fragment VersionDetails on DefinitionVersion {
-        id
-        nodeId
-        uuid
-        definitionId
-        name
-        description
-        sourceType
-        source
-        registryAccess
-        __typename
-      }
-    `, {
-            definitionId,
-            versionId,
-            updatePatch,
-        });
-    }
-    getOrganizationId(organizationId) {
-        return this.query(`
-      query ($organizationId: String!) {
-        organizationById(id: $organizationId) {
-          id
-        }
-      }
-    `, {
-            organizationId
-        });
-    }
-    getDefinitionByName(name, organizationId) {
-        return this.query(`
-      query ($name: String!, $organizationId: String!) {
-        definition: definitionByOrganizationIdAndName(name: $name, organizationId: $organizationId) {
-          id
-        }
-      }
-    `, {
-            name,
-            organizationId
-        });
-    }
-    createDefinition(organizationId, name) {
-        return this.query(`
-      mutation CreateDefinition($organizationId: String!, $name: String!) {
-        def: createDefinition(input: {organizationId: $organizationId, name: $name }) {
-          definition {
-            id
-            nodeId
-            name
-          }
-        }
-      }
-    `, {
-            organizationId,
-            name
-        });
-    }
-    createDefinitionVersion(definitionId, name, sourceType, source) {
-        return this.query(`
-      mutation CreateVersion($definitionId: Int!, $name: String!, $sourceType: DvSourceType!, $source: JSON) {
-        createDefinitionVersion(input: {definitionId: $definitionId, name: $name, sourceType: $sourceType, source: $source }) {
-          definitionVersion {
-            id
-          }
-        }
-      }
-    `, {
-            definitionId,
-            name,
-            sourceType,
-            source
-        });
-    }
-    getSignedUrl(organizationId, filesHash, fileName) {
-        return this.query(`
-      query ($organizationId: String!, $filesHash: String!, $fileName: String!) {
-        signFileUploadCLI(organizationId: $organizationId, filesHash: $filesHash, fileName: $fileName) {
-          signedFileUrl
-          uploadedFilePath
-        }
-      }
-    `, {
-            organizationId,
-            filesHash,
-            fileName
-        });
-    }
-    getDefinitionVersion(organizationId, definitionName, versionName) {
-        return this.query(`
-      query ($organizationId: String!, $definitionName: String!, $versionName: String!) {
-        version: definitionVersionByOrganizationDefinitionAndName(organizationId: $organizationId, definitionName: $definitionName, versionName: $versionName) {
-          id
-          definitionId
-          defaultBranch {
-            name
-          }
-        }
-      }
-    `, {
-            organizationId,
-            definitionName,
-            versionName
-        });
-    }
-    static isRegistryURL(link) {
-        const domain = process.env.REDOCLY_DOMAIN || 'redoc.ly';
-        if (!link.startsWith(`https://api.${domain}/registry/`))
-            return false;
-        const registryPath = link.replace(`https://api.${domain}/registry/`, '');
-        const pathParts = registryPath.split('/');
-        // we can be sure, that there is job UUID present
-        // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
-        // so skip this link.
-        // FIXME
-        if (pathParts.length === 7)
-            return false;
-        return true;
-    }
 }
 exports.RedoclyClient = RedoclyClient;
+function isRedoclyRegistryURL(link) {
+    const domain = process.env.REDOCLY_DOMAIN || 'redoc.ly';
+    if (!link.startsWith(`https://api.${domain}/registry/`))
+        return false;
+    const registryPath = link.replace(`https://api.${domain}/registry/`, '');
+    const pathParts = registryPath.split('/');
+    // we can be sure, that there is job UUID present
+    // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
+    // so skip this link.
+    // FIXME
+    if (pathParts.length === 7)
+        return false;
+    return true;
+}
+exports.isRedoclyRegistryURL = isRedoclyRegistryURL;

package/lib/redocly/registry-api-types.d.ts

@@ -0,0 +1,28 @@
+export declare namespace RegistryApiTypes {
+    interface VersionParams {
+        organizationId: string;
+        name: string;
+        version: string;
+    }
+    export interface PrepareFileuploadParams extends VersionParams {
+        filesHash: string;
+        filename: string;
+        isUpsert?: boolean;
+    }
+    export interface PushApiParams extends VersionParams {
+        rootFilePath: string;
+        filePaths: string[];
+        branch?: string;
+        isUpsert?: boolean;
+    }
+    export interface PrepareFileuploadOKResponse {
+        filePath: string;
+        signedUploadUrl: string;
+    }
+    export interface NotFoundProblemResponse {
+        status: 404;
+        title: 'Not Found';
+        code: 'ORGANIZATION_NOT_FOUND' | 'API_VERSION_NOT_FOUND';
+    }
+    export {};
+}

package/lib/redocly/registry-api-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/redocly/registry-api.d.ts

@@ -0,0 +1,11 @@
+import { RegistryApiTypes } from './registry-api-types';
+export declare class RegistryApi {
+    private accessToken?;
+    private readonly baseUrl;
+    constructor(accessToken?: string | undefined);
+    private request;
+    setAccessToken(accessToken: string): this;
+    authStatus(verbose?: boolean): Promise<boolean>;
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }: RegistryApiTypes.PushApiParams): Promise<void>;
+}

package/lib/redocly/registry-api.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryApi = void 0;
+const node_fetch_1 = require("node-fetch");
+const version = require('../../package.json').version;
+class RegistryApi {
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+        this.baseUrl = `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry`;
+    }
+    request(path = '', options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accessToken) {
+                throw new Error('Unauthorized');
+            }
+            const headers = Object.assign({}, options.headers || {}, {
+                authorization: this.accessToken,
+                'x-redocly-cli-version': version,
+            });
+            const response = yield node_fetch_1.default(`${this.baseUrl}${path}`, Object.assign({}, options, { headers }));
+            if (response.status === 401) {
+                throw new Error('Unauthorized');
+            }
+            if (response.status === 404) {
+                const body = yield response.json();
+                throw new Error(body.code);
+            }
+            return response;
+        });
+    }
+    setAccessToken(accessToken) {
+        this.accessToken = accessToken;
+        return this;
+    }
+    authStatus(verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.request();
+                return response.ok;
+            }
+            catch (error) {
+                if (verbose) {
+                    console.log(error);
+                }
+                return false;
+            }
+        });
+    }
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    filesHash,
+                    filename,
+                    isUpsert,
+                }),
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            throw new Error('Could not prepare file upload');
+        });
+    }
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}`, {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    rootFilePath,
+                    filePaths,
+                    branch,
+                    isUpsert,
+                }),
+            });
+            if (response.ok) {
+                return;
+            }
+            throw new Error('Could not push api');
+        });
+    }
+}
+exports.RegistryApi = RegistryApi;

package/lib/ref-utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
-const path_1 = require("path");
 function joinPointer(base, key) {
     if (base === '')
         base = '#/';
@@ -56,7 +55,7 @@ function pointerBaseName(pointer) {
 }
 exports.pointerBaseName = pointerBaseName;
 function refBaseName(ref) {
-    const parts = ref.split(path_1.sep);
+    const parts = ref.split(/[\/\\]/); // split by '\' and '/'
     return parts[parts.length - 1].split('.')[0];
 }
 exports.refBaseName = refBaseName;

package/lib/rules/common/info-license-url.js

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

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

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const NoHttpVerbsInPaths: Oas3Rule | Oas2Rule;

package/lib/rules/common/no-http-verbs-in-paths.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoHttpVerbsInPaths = void 0;
+const utils_1 = require("../../utils");
+const httpMethods = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+const NoHttpVerbsInPaths = ({ splitIntoWords }) => {
+    return {
+        PathItem(_path, { key, report, location }) {
+            const pathKey = key.toString();
+            if (!pathKey.startsWith('/'))
+                return;
+            const pathSegments = pathKey.split('/');
+            for (const pathSegment of pathSegments) {
+                if (!pathSegment || utils_1.isPathParameter(pathSegment))
+                    continue;
+                const isHttpMethodIncluded = (method) => {
+                    return splitIntoWords
+                        ? utils_1.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(),
+                        });
+                    }
+                }
+            }
+        },
+    };
+};
+exports.NoHttpVerbsInPaths = NoHttpVerbsInPaths;

package/lib/rules/common/operation-4xx-response.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const Operation4xxResponse: Oas3Rule | Oas2Rule;

package/lib/rules/common/operation-4xx-response.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation4xxResponse = void 0;
+const Operation4xxResponse = () => {
+    return {
+        ResponsesMap(responses, { report }) {
+            const codes = Object.keys(responses);
+            if (!codes.some((code) => /4[Xx0-9]{2}/.test(code))) {
+                report({
+                    message: 'Operation must have at least one `4xx` response.',
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.Operation4xxResponse = Operation4xxResponse;

package/lib/rules/common/path-excludes-patterns.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const PathExcludesPatterns: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-excludes-patterns.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathExcludesPatterns = void 0;
+const PathExcludesPatterns = ({ patterns }) => {
+    return {
+        PathItem(_path, { report, key, location }) {
+            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) => pathKey.match(pattern));
+                for (const match of matches) {
+                    report({
+                        message: `path \`${pathKey}\` should not match regex pattern: \`${match}\``,
+                        location: location.key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.PathExcludesPatterns = PathExcludesPatterns;

package/lib/rules/common/path-segment-plural.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathSegmentPlural: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-segment-plural.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathSegmentPlural = void 0;
+const utils_1 = require("../../utils");
+const PathSegmentPlural = (opts) => {
+    const { ignoreLastPathSegment, exceptions } = opts;
+    return {
+        PathItem: {
+            leave(_path, { report, key, location }) {
+                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 (!utils_1.isPathParameter(pathSegment) && utils_1.isSingular(pathSegment)) {
+                            report({
+                                message: `path segment \`${pathSegment}\` should be plural.`,
+                                location: location.key(),
+                            });
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+exports.PathSegmentPlural = PathSegmentPlural;

package/lib/rules/common/registry-dependencies.js

@@ -3,21 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryDependencies = void 0;
 const redocly_1 = require("../../redocly");
 const RegistryDependencies = () => {
-    let redoclyClient;
     let registryDependencies = new Set();
     return {
         DefinitionRoot: {
-            leave() {
-                redoclyClient = new redocly_1.RedoclyClient();
-                if (process.env.UPDATE_REGISTRY && redoclyClient.hasToken()) {
-                    redoclyClient.updateDependencies(Array.from(registryDependencies.keys()));
-                }
+            leave(_, ctx) {
+                const data = ctx.getVisitorData();
+                data.links = Array.from(registryDependencies);
             },
         },
         ref(node) {
             if (node.$ref) {
                 const link = node.$ref.split('#/')[0];
-                if (redocly_1.RedoclyClient.isRegistryURL(link)) {
+                if (redocly_1.isRedoclyRegistryURL(link)) {
                     registryDependencies.add(link);
                 }
             }

package/lib/rules/oas2/index.d.ts

@@ -12,6 +12,7 @@ export declare const rules: {
     'boolean-parameter-prefixes': Oas2Rule;
     'no-path-trailing-slash': Oas2Rule;
     'operation-2xx-response': Oas2Rule;
+    'operation-4xx-response': Oas2Rule;
     'operation-operationId-unique': Oas2Rule;
     'operation-parameters-unique': Oas2Rule;
     'path-parameters-defined': Oas2Rule;
@@ -30,6 +31,11 @@ export declare const rules: {
     'no-identical-paths': Oas2Rule;
     'no-ambiguous-paths': Oas2Rule;
     'path-http-verbs-order': Oas2Rule;
+    'no-http-verbs-in-paths': Oas2Rule;
+    'path-excludes-patterns': Oas2Rule;
+    'request-mime-type': Oas2Rule;
+    'response-mime-type': Oas2Rule;
+    'path-segment-plural': Oas2Rule;
 };
 export declare const preprocessors: {};
 export declare const decorators: {

package/lib/rules/oas2/index.js

@@ -13,6 +13,7 @@ const paths_kebab_case_1 = require("../common/paths-kebab-case");
 const no_enum_type_mismatch_1 = require("../common/no-enum-type-mismatch");
 const no_path_trailing_slash_1 = require("../common/no-path-trailing-slash");
 const operation_2xx_response_1 = require("../common/operation-2xx-response");
+const operation_4xx_response_1 = require("../common/operation-4xx-response");
 const operation_operationId_unique_1 = require("../common/operation-operationId-unique");
 const operation_parameters_unique_1 = require("../common/operation-parameters-unique");
 const path_params_defined_1 = require("../common/path-params-defined");
@@ -31,6 +32,11 @@ const no_identical_paths_1 = require("../common/no-identical-paths");
 const operation_operationId_1 = require("../common/operation-operationId");
 const operation_summary_1 = require("../common/operation-summary");
 const no_ambiguous_paths_1 = require("../common/no-ambiguous-paths");
+const no_http_verbs_in_paths_1 = require("../common/no-http-verbs-in-paths");
+const path_excludes_patterns_1 = require("../common/path-excludes-patterns");
+const request_mime_type_1 = require("./request-mime-type");
+const response_mime_type_1 = require("./response-mime-type");
+const path_segment_plural_1 = require("../common/path-segment-plural");
 const operation_description_override_1 = require("../common/operation-description-override");
 const tag_description_override_1 = require("../common/tag-description-override");
 const info_description_override_1 = require("../common/info-description-override");
@@ -47,6 +53,7 @@ exports.rules = {
     'boolean-parameter-prefixes': boolean_parameter_prefixes_1.BooleanParameterPrefixes,
     'no-path-trailing-slash': no_path_trailing_slash_1.NoPathTrailingSlash,
     'operation-2xx-response': operation_2xx_response_1.Operation2xxResponse,
+    'operation-4xx-response': operation_4xx_response_1.Operation4xxResponse,
     'operation-operationId-unique': operation_operationId_unique_1.OperationIdUnique,
     'operation-parameters-unique': operation_parameters_unique_1.OperationParametersUnique,
     'path-parameters-defined': path_params_defined_1.PathParamsDefined,
@@ -65,6 +72,11 @@ exports.rules = {
     'no-identical-paths': no_identical_paths_1.NoIdenticalPaths,
     'no-ambiguous-paths': no_ambiguous_paths_1.NoAmbiguousPaths,
     'path-http-verbs-order': path_http_verbs_order_1.PathHttpVerbsOrder,
+    'no-http-verbs-in-paths': no_http_verbs_in_paths_1.NoHttpVerbsInPaths,
+    'path-excludes-patterns': path_excludes_patterns_1.PathExcludesPatterns,
+    'request-mime-type': request_mime_type_1.RequestMimeType,
+    'response-mime-type': response_mime_type_1.ResponseMimeType,
+    'path-segment-plural': path_segment_plural_1.PathSegmentPlural,
 };
 exports.preprocessors = {};
 exports.decorators = {

package/lib/rules/oas2/request-mime-type.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule } from '../../visitors';
+export declare const RequestMimeType: Oas2Rule;

package/lib/rules/oas2/request-mime-type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMimeType = void 0;
+const utils_1 = require("../../utils");
+const RequestMimeType = ({ allowedValues }) => {
+    return {
+        DefinitionRoot(root, ctx) {
+            utils_1.validateMimeType({ type: 'consumes', value: root }, ctx, allowedValues);
+        },
+        Operation: {
+            leave(operation, ctx) {
+                utils_1.validateMimeType({ type: 'consumes', value: operation }, ctx, allowedValues);
+            },
+        },
+    };
+};
+exports.RequestMimeType = RequestMimeType;

package/lib/rules/oas2/response-mime-type.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule } from '../../visitors';
+export declare const ResponseMimeType: Oas2Rule;

package/lib/rules/oas2/response-mime-type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseMimeType = void 0;
+const utils_1 = require("../../utils");
+const ResponseMimeType = ({ allowedValues }) => {
+    return {
+        DefinitionRoot(root, ctx) {
+            utils_1.validateMimeType({ type: 'produces', value: root }, ctx, allowedValues);
+        },
+        Operation: {
+            leave(operation, ctx) {
+                utils_1.validateMimeType({ type: 'produces', value: operation }, ctx, allowedValues);
+            },
+        },
+    };
+};
+exports.ResponseMimeType = ResponseMimeType;