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

package/__tests__/lint.test.ts

@@ -2,7 +2,7 @@ import outdent from 'outdent';
 import { detectOpenAPI } from '../src/oas-types';
 import { parseYamlToDocument } from './utils';
 
-describe.only('lint', () => {
+describe('lint', () => {
 	it('detect OpenAPI should throw an error when version is not string', () => {
 
 	const testDocument = parseYamlToDocument(

package/__tests__/login.test.ts

@@ -0,0 +1,17 @@
+import { RedoclyClient } from '../src/redocly';
+
+describe('login', () => {
+  it('should call login with setAccessTokens function', async () => {
+    const client = new RedoclyClient();
+    Object.defineProperty(client, 'registryApi', {
+      value: {
+        setAccessTokens: jest.fn(),
+        authStatus: jest.fn(() => true)
+      },
+      writable: true,
+      configurable: true
+    });
+    await client.login('token');
+    expect(client.registryApi.setAccessTokens).toHaveBeenCalled();
+  });
+});

package/lib/config/all.js

@@ -38,6 +38,8 @@ exports.default = {
         },
         'request-mime-type': 'error',
         spec: 'error',
+        'no-invalid-schema-examples': 'error',
+        'no-invalid-parameter-examples': 'error',
     },
     oas3_0Rules: {
         'no-invalid-media-type-examples': 'error',

package/lib/config/config.d.ts

@@ -70,11 +70,20 @@ export declare type HttpResolveConfig = {
 export declare type ResolveConfig = {
     http: HttpResolveConfig;
 };
+export declare const DEFAULT_REGION = "us";
+export declare type Region = 'us' | 'eu';
+export declare type AccessTokens = {
+    [region in Region]?: string;
+};
+export declare const DOMAINS: {
+    [region in Region]: string;
+};
 export declare type RawConfig = {
     referenceDocs?: any;
     apiDefinitions?: Record<string, string>;
     lint?: LintRawConfig;
     resolve?: RawResolveConfig;
+    region?: Region;
 };
 export declare class LintConfig {
     rawConfig: LintRawConfig;
@@ -126,5 +135,6 @@ export declare class Config {
     lint: LintConfig;
     resolve: ResolveConfig;
     licenseKey?: string;
+    region?: Region;
     constructor(rawConfig: RawConfig, configFile?: string | undefined);
 }

package/lib/config/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = exports.LintConfig = exports.IGNORE_FILE = void 0;
+exports.Config = exports.LintConfig = exports.DOMAINS = exports.DEFAULT_REGION = exports.IGNORE_FILE = void 0;
 const fs = require("fs");
 const path = require("path");
 const path_1 = require("path");
@@ -12,6 +12,11 @@ const recommended_1 = require("./recommended");
 exports.IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
     `# See https://redoc.ly/docs/cli/ for more information.\n`;
+exports.DEFAULT_REGION = 'us';
+exports.DOMAINS = {
+    us: 'redoc.ly',
+    eu: 'eu.redocly.com',
+};
 class LintConfig {
     constructor(rawConfig, configFile) {
         this.rawConfig = rawConfig;
@@ -233,6 +238,7 @@ class Config {
                 customFetch: undefined,
             },
         };
+        this.region = rawConfig.region;
     }
 }
 exports.Config = Config;

package/lib/config/load.js

@@ -35,20 +35,29 @@ function loadConfig(configPath, customExtends) {
             rawConfig.lint.extends = customExtends;
         }
         const redoclyClient = new redocly_1.RedoclyClient();
-        if (redoclyClient.hasToken()) {
+        const tokens = yield redoclyClient.getTokens();
+        if (tokens.length) {
             if (!rawConfig.resolve)
                 rawConfig.resolve = {};
             if (!rawConfig.resolve.http)
                 rawConfig.resolve.http = {};
-            rawConfig.resolve.http.headers = [
-                {
-                    matches: `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry/**`,
+            rawConfig.resolve.http.headers = [...((_a = rawConfig.resolve.http.headers) !== null && _a !== void 0 ? _a : [])];
+            for (const item of tokens) {
+                const domain = config_1.DOMAINS[item.region];
+                rawConfig.resolve.http.headers.push({
+                    matches: `https://api.${domain}/registry/**`,
                     name: 'Authorization',
                     envVariable: undefined,
-                    value: (redoclyClient && (yield redoclyClient.getAuthorizationHeader())) || '',
-                },
-                ...((_a = rawConfig.resolve.http.headers) !== null && _a !== void 0 ? _a : []),
-            ];
+                    value: item.token,
+                }, 
+                //support redocly.com domain for future compatibility
+                ...(item.region === 'us' ? [{
+                        matches: `https://api.redocly.com/registry/**`,
+                        name: 'Authorization',
+                        envVariable: undefined,
+                        value: item.token,
+                    }] : []));
+            }
         }
         return new config_1.Config(Object.assign(Object.assign({}, rawConfig), { lint: Object.assign(Object.assign({}, rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint), { plugins: [...(((_b = rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint) === null || _b === void 0 ? void 0 : _b.plugins) || []), builtIn_1.defaultPlugin] }) }), configPath);
     });

package/lib/index.d.ts

@@ -8,7 +8,7 @@ export { Oas2Definition } from './typings/swagger';
 export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
-export { Config, LintConfig, RawConfig, IGNORE_FILE } from './config/config';
+export { Config, LintConfig, RawConfig, IGNORE_FILE, Region } from './config/config';
 export { loadConfig } from './config/load';
 export { RedoclyClient } from './redocly';
 export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError, makeDocumentFromString, } from './resolve';
@@ -19,5 +19,5 @@ export { normalizeVisitors } from './visitors';
 export { WalkContext, walkDocument, NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject, Loc, } from './walk';
 export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
 export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
-export { lint, lint as validate, lintDocument, lintFromString, lintConfig, } from './lint';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
 export { bundle, bundleDocument } from './bundle';

package/lib/redocly/index.d.ts

@@ -1,13 +1,29 @@
 import { RegistryApi } from './registry-api';
+import { AccessTokens, Region } from '../config/config';
 export declare class RedoclyClient {
-    private accessToken;
+    private accessTokens;
+    private region;
+    domain: string;
     registryApi: RegistryApi;
-    constructor();
-    hasToken(): boolean;
-    loadToken(): void;
+    constructor(region?: Region);
+    loadRegion(region?: Region): Region;
+    hasTokens(): boolean;
+    setAccessTokens(accessTokens: AccessTokens): void;
+    loadTokens(): void;
+    getValidTokens(): Promise<{
+        region: string;
+        token: string;
+        valid: boolean;
+    }[]>;
+    getTokens(): Promise<{
+        region: string;
+        token: string;
+        valid: boolean;
+    }[]>;
+    isAuthorizedWithRedoclyByRegion(): Promise<boolean>;
     isAuthorizedWithRedocly(): Promise<boolean>;
-    verifyToken(accessToken: string, verbose?: boolean): Promise<boolean>;
-    getAuthorizationHeader(): Promise<string | undefined>;
+    readCredentialsFile(credentialsPath: string): any;
+    verifyToken(accessToken: string, region: Region, verbose?: boolean): Promise<boolean>;
     login(accessToken: string, verbose?: boolean): Promise<void>;
     logout(): void;
 }

package/lib/redocly/index.js

@@ -15,61 +15,91 @@ const path_1 = require("path");
 const os_1 = require("os");
 const colorette_1 = require("colorette");
 const registry_api_1 = require("./registry-api");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
 const TOKEN_FILENAME = '.redocly-config.json';
 class RedoclyClient {
-    constructor() {
-        this.loadToken();
-        this.registryApi = new registry_api_1.RegistryApi(this.accessToken);
+    constructor(region) {
+        this.accessTokens = {};
+        this.region = this.loadRegion(region);
+        this.loadTokens();
+        this.domain = region
+            ? config_1.DOMAINS[region]
+            : process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+        this.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
     }
-    hasToken() {
-        return !!this.accessToken;
-    }
-    loadToken() {
-        if (process.env.REDOCLY_AUTHORIZATION) {
-            this.accessToken = process.env.REDOCLY_AUTHORIZATION;
-            return;
+    loadRegion(region) {
+        if (region && !config_1.DOMAINS[region]) {
+            process.stdout.write(colorette_1.red(`Invalid argument: region in config file.\nGiven: ${colorette_1.green(region)}, choices: "us", "eu".\n`));
+            process.exit(1);
         }
+        return region || config_1.DEFAULT_REGION;
+    }
+    hasTokens() {
+        return utils_1.isNotEmptyObject(this.accessTokens);
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+    }
+    loadTokens() {
         const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
-        if (fs_1.existsSync(credentialsPath)) {
-            const credentials = JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8'));
-            this.accessToken = credentials && credentials.token;
+        const credentials = this.readCredentialsFile(credentialsPath);
+        if (utils_1.isNotEmptyObject(credentials)) {
+            this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token && !credentials[this.region] && {
+                [this.region]: credentials.token
+            })));
+        }
+        if (process.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: process.env.REDOCLY_AUTHORIZATION }));
         }
     }
-    isAuthorizedWithRedocly() {
+    getValidTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.hasToken() && !!(yield this.getAuthorizationHeader());
+            return (yield Promise.all(Object.entries(this.accessTokens).map(([key, value]) => __awaiter(this, void 0, void 0, function* () {
+                return { region: key, token: value, valid: yield this.verifyToken(value, key) };
+            })))).filter(item => Boolean(item.valid));
         });
     }
-    verifyToken(accessToken, verbose = false) {
+    getTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!accessToken)
+            return this.hasTokens() ? yield this.getValidTokens() : [];
+        });
+    }
+    isAuthorizedWithRedoclyByRegion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.hasTokens())
                 return false;
-            return this.registryApi.setAccessToken(accessToken).authStatus(verbose);
+            const accessToken = this.accessTokens[this.region];
+            return !!accessToken && (yield this.verifyToken(accessToken, this.region));
         });
     }
-    getAuthorizationHeader() {
+    isAuthorizedWithRedocly() {
         return __awaiter(this, void 0, void 0, function* () {
-            // print this only if there is token but invalid
-            if (this.accessToken && !(yield this.verifyToken(this.accessToken))) {
-                process.stderr.write(`${colorette_1.yellow('Warning:')} invalid Redocly API key. Use "npx @redocly/openapi-cli login" to provide your API key\n`);
-                return undefined;
-            }
-            return this.accessToken;
+            return this.hasTokens() && utils_1.isNotEmptyObject(yield this.getValidTokens());
+        });
+    }
+    readCredentialsFile(credentialsPath) {
+        return fs_1.existsSync(credentialsPath) ? JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8')) : {};
+    }
+    verifyToken(accessToken, region, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!accessToken)
+                return false;
+            return this.registryApi.authStatus(accessToken, region, verbose);
         });
     }
     login(accessToken, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
             const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
             process.stdout.write(colorette_1.gray('\n  Logging in...\n'));
-            const authorized = yield this.verifyToken(accessToken, verbose);
+            const authorized = yield this.verifyToken(accessToken, this.region, verbose);
             if (!authorized) {
                 process.stdout.write(colorette_1.red('Authorization failed. Please check if you entered a valid API key.\n'));
                 process.exit(1);
             }
-            this.accessToken = accessToken;
-            const credentials = {
-                token: accessToken,
-            };
+            const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken });
+            this.accessTokens = credentials;
+            this.registryApi.setAccessTokens(credentials);
             fs_1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
             process.stdout.write(colorette_1.green('  Authorization confirmed. ✅\n\n'));
         });
@@ -84,7 +114,7 @@ class RedoclyClient {
 }
 exports.RedoclyClient = RedoclyClient;
 function isRedoclyRegistryURL(link) {
-    const domain = process.env.REDOCLY_DOMAIN || 'redoc.ly';
+    const domain = process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
     if (!link.startsWith(`https://api.${domain}/registry/`))
         return false;
     const registryPath = link.replace(`https://api.${domain}/registry/`, '');

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

@@ -1,11 +1,14 @@
 import { RegistryApiTypes } from './registry-api-types';
+import { AccessTokens, Region } from '../config/config';
 export declare class RegistryApi {
-    private accessToken?;
-    private readonly baseUrl;
-    constructor(accessToken?: string | undefined);
+    private accessTokens;
+    private region;
+    constructor(accessTokens: AccessTokens, region: Region);
+    get accessToken(): string | false | undefined;
+    getBaseUrl(region?: Region): string;
+    setAccessTokens(accessTokens: AccessTokens): this;
     private request;
-    setAccessToken(accessToken: string): this;
-    authStatus(verbose?: boolean): Promise<boolean>;
+    authStatus(accessToken: string, region: Region, 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

@@ -11,22 +11,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryApi = void 0;
 const node_fetch_1 = require("node-fetch");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
 const version = require('../../package.json').version;
 class RegistryApi {
-    constructor(accessToken) {
-        this.accessToken = accessToken;
-        this.baseUrl = `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry`;
+    constructor(accessTokens, region) {
+        this.accessTokens = accessTokens;
+        this.region = region;
     }
-    request(path = '', options = {}) {
+    get accessToken() {
+        return utils_1.isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
+    }
+    getBaseUrl(region = config_1.DEFAULT_REGION) {
+        return `https://api.${config_1.DOMAINS[region]}/registry`;
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+        return this;
+    }
+    request(path = '', options = {}, region) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.accessToken) {
+            const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
+            if (!headers.hasOwnProperty('authorization')) {
                 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 }));
+            const response = yield node_fetch_1.default(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
             if (response.status === 401) {
                 throw new Error('Unauthorized');
             }
@@ -37,14 +46,10 @@ class RegistryApi {
             return response;
         });
     }
-    setAccessToken(accessToken) {
-        this.accessToken = accessToken;
-        return this;
-    }
-    authStatus(verbose = false) {
+    authStatus(accessToken, region, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const response = yield this.request();
+                const response = yield this.request('', { headers: { authorization: accessToken } }, region);
                 return response.ok;
             }
             catch (error) {
@@ -59,13 +64,16 @@ class RegistryApi {
         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' },
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.accessToken,
+                },
                 body: JSON.stringify({
                     filesHash,
                     filename,
                     isUpsert,
                 }),
-            });
+            }, this.region);
             if (response.ok) {
                 return response.json();
             }
@@ -76,14 +84,17 @@ class RegistryApi {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.request(`/${organizationId}/${name}/${version}`, {
                 method: 'PUT',
-                headers: { 'content-type': 'application/json' },
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.accessToken
+                },
                 body: JSON.stringify({
                     rootFilePath,
                     filePaths,
                     branch,
                     isUpsert,
                 }),
-            });
+            }, this.region);
             if (response.ok) {
                 return;
             }

package/lib/rules/common/no-invalid-parameter-examples.d.ts

@@ -0,0 +1 @@
+export declare const NoInvalidParameterExamples: any;

package/lib/rules/common/no-invalid-parameter-examples.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidParameterExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidParameterExamples = (opts) => {
+    var _a;
+    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    return {
+        Parameter: {
+            leave(parameter, ctx) {
+                if (parameter.example) {
+                    utils_1.validateExample(parameter.example, parameter.schema, ctx.location.child('example'), ctx, disallowAdditionalProperties);
+                }
+                if (parameter.examples) {
+                    for (const [key, example] of Object.entries(parameter.examples)) {
+                        if ('value' in example) {
+                            utils_1.validateExample(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, false);
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidParameterExamples = NoInvalidParameterExamples;

package/lib/rules/common/no-invalid-schema-examples.d.ts

@@ -0,0 +1 @@
+export declare const NoInvalidSchemaExamples: any;

package/lib/rules/common/no-invalid-schema-examples.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidSchemaExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidSchemaExamples = (opts) => {
+    var _a;
+    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    return {
+        Schema: {
+            leave(schema, ctx) {
+                if (schema.examples) {
+                    for (const example of schema.examples) {
+                        utils_1.validateExample(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, disallowAdditionalProperties);
+                    }
+                }
+                if (schema.example) {
+                    utils_1.validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidSchemaExamples = NoInvalidSchemaExamples;

package/lib/rules/common/paths-kebab-case.js

@@ -4,7 +4,7 @@ exports.PathsKebabCase = void 0;
 const PathsKebabCase = () => {
     return {
         PathItem(_path, { report, key }) {
-            const segments = key.substr(1).split('/');
+            const segments = key.substr(1).split('/').filter(s => s !== ''); // filter out empty segments
             if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
                 report({
                     message: `\`${key}\` does not use kebab-case.`,

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

@@ -1,6 +1,8 @@
 import { Oas2Decorator, Oas2Rule } from '../../visitors';
 export declare const rules: {
     spec: Oas2Rule;
+    'no-invalid-schema-examples': any;
+    'no-invalid-parameter-examples': any;
     'info-description': Oas2Rule;
     'info-contact': Oas2Rule;
     'info-license': Oas2Rule;

package/lib/rules/oas2/index.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decorators = exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
+const no_invalid_schema_examples_1 = require("../common/no-invalid-schema-examples");
+const no_invalid_parameter_examples_1 = require("../common/no-invalid-parameter-examples");
 const info_description_1 = require("../common/info-description");
 const info_contact_1 = require("../common/info-contact");
 const info_license_url_1 = require("../common/info-license-url");
@@ -42,6 +44,8 @@ const tag_description_override_1 = require("../common/tag-description-override")
 const info_description_override_1 = require("../common/info-description-override");
 exports.rules = {
     spec: spec_1.OasSpec,
+    'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
+    'no-invalid-parameter-examples': no_invalid_parameter_examples_1.NoInvalidParameterExamples,
     'info-description': info_description_1.InfoDescription,
     'info-contact': info_contact_1.InfoContact,
     'info-license': info_license_url_1.InfoLicense,

package/lib/rules/oas3/index.js

@@ -48,6 +48,8 @@ const operation_description_override_1 = require("../common/operation-descriptio
 const tag_description_override_1 = require("../common/tag-description-override");
 const info_description_override_1 = require("../common/info-description-override");
 const path_excludes_patterns_1 = require("../common/path-excludes-patterns");
+const no_invalid_schema_examples_1 = require("../common/no-invalid-schema-examples");
+const no_invalid_parameter_examples_1 = require("../common/no-invalid-parameter-examples");
 exports.rules = {
     spec: spec_1.OasSpec,
     'info-description': info_description_1.InfoDescription,
@@ -93,6 +95,8 @@ exports.rules = {
     'request-mime-type': request_mime_type_1.RequestMimeType,
     'response-mime-type': response_mime_type_1.ResponseMimeType,
     'path-segment-plural': path_segment_plural_1.PathSegmentPlural,
+    'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
+    'no-invalid-parameter-examples': no_invalid_parameter_examples_1.NoInvalidParameterExamples,
 };
 exports.preprocessors = {};
 exports.decorators = {

package/lib/rules/oas3/no-invalid-media-type-examples.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidContentExamples = void 0;
-const ajv_1 = require("../ajv");
 const ref_utils_1 = require("../../ref-utils");
+const utils_1 = require("../utils");
 const ValidContentExamples = (opts) => {
     var _a;
     const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
     return {
         MediaType: {
-            leave(mediaType, { report, location, resolve }) {
+            leave(mediaType, ctx) {
+                const { location, resolve } = ctx;
                 if (!mediaType.schema)
                     return;
                 if (mediaType.example) {
-                    validateExample(mediaType.example, location.child('example'));
+                    utils_1.validateExample(mediaType.example, mediaType.schema, location.child('example'), ctx, disallowAdditionalProperties);
                 }
                 else if (mediaType.examples) {
                     for (const exampleName of Object.keys(mediaType.examples)) {
@@ -25,29 +26,7 @@ const ValidContentExamples = (opts) => {
                             dataLoc = resolved.location.child('value');
                             example = resolved.node;
                         }
-                        validateExample(example.value, dataLoc);
-                    }
-                }
-                function validateExample(example, dataLoc) {
-                    try {
-                        const { valid, errors } = ajv_1.validateJsonSchema(example, mediaType.schema, location.child('schema'), dataLoc.pointer, resolve, disallowAdditionalProperties);
-                        if (!valid) {
-                            for (let error of errors) {
-                                report({
-                                    message: `Example value must conform to the schema: ${error.message}.`,
-                                    location: Object.assign(Object.assign({}, new ref_utils_1.Location(dataLoc.source, error.instancePath)), { reportOnKey: error.keyword === 'additionalProperties' }),
-                                    from: location,
-                                    suggest: error.suggest,
-                                });
-                            }
-                        }
-                    }
-                    catch (e) {
-                        report({
-                            message: `Example validation errored: ${e.message}.`,
-                            location: location.child('schema'),
-                            from: location
-                        });
+                        utils_1.validateExample(example.value, mediaType.schema, dataLoc, ctx, disallowAdditionalProperties);
                     }
                 }
             },

package/lib/rules/utils.d.ts

@@ -1,4 +1,6 @@
 import { UserContext } from '../walk';
+import { Location } from '../ref-utils';
+import { Oas3Schema, Referenced } from '../typings/openapi';
 export declare function oasTypeOf(value: unknown): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null";
 /**
  * Checks if value matches specified JSON schema type
@@ -12,3 +14,4 @@ export declare function missingRequiredField(type: string, field: string): strin
 export declare function fieldNonEmpty(type: string, field: string): string;
 export declare function validateDefinedAndNonEmpty(fieldName: string, value: any, ctx: UserContext): void;
 export declare function getSuggest(given: string, variants: string[]): string[];
+export declare function validateExample(example: any, schema: Referenced<Oas3Schema>, dataLoc: Location, { resolve, location, report }: UserContext, disallowAdditionalProperties: boolean): void;