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

package/lib/rules/utils.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
+exports.validateExample = exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
 const levenshtein = require("js-levenshtein");
+const ref_utils_1 = require("../ref-utils");
+const ajv_1 = require("./ajv");
 function oasTypeOf(value) {
     if (Array.isArray(value)) {
         return 'array';
@@ -80,3 +82,26 @@ function getSuggest(given, variants) {
     return distances.map((d) => d.variant);
 }
 exports.getSuggest = getSuggest;
+function validateExample(example, schema, dataLoc, { resolve, location, report }, disallowAdditionalProperties) {
+    try {
+        const { valid, errors } = ajv_1.validateJsonSchema(example, 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,
+        });
+    }
+}
+exports.validateExample = validateExample;

package/lib/typings/openapi.d.ts

@@ -144,6 +144,9 @@ export interface Oas3Schema {
     example?: any;
     xml?: Oas3Xml;
 }
+export interface Oas3_1Schema extends Oas3Schema {
+    examples?: any[];
+}
 export interface Oas3Discriminator {
     propertyName: string;
     mapping?: {

package/lib/utils.d.ts

@@ -33,3 +33,4 @@ export declare function isPathParameter(pathSegment: string): boolean;
  * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
  */
 export declare function slash(path: string): string;
+export declare function isNotEmptyObject(obj: any): boolean;

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.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const minimatch = require("minimatch");
 const node_fetch_1 = require("node-fetch");
@@ -144,3 +144,7 @@ function slash(path) {
     return path.replace(/\\/g, '/');
 }
 exports.slash = slash;
+function isNotEmptyObject(obj) {
+    return !!obj && Object.keys(obj).length > 0;
+}
+exports.isNotEmptyObject = isNotEmptyObject;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.69",
+  "version": "1.0.0-beta.73",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -50,4 +50,4 @@
     "@types/pluralize": "^0.0.29",
     "typescript": "^4.0.5"
   }
-}
+}

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

@@ -0,0 +1,35 @@
+import { loadConfig } from '../load';
+import { RedoclyClient } from '../../redocly';
+
+describe('loadConfig', () => {
+  it('should resolve config http header by US region', async () => {
+    jest.spyOn(RedoclyClient.prototype, 'getTokens').mockImplementation(
+      () => Promise.resolve([{ region: 'us', token: "accessToken", valid: true }])
+    );
+    const config = await loadConfig();
+    expect(config.resolve.http.headers).toStrictEqual([{
+      "matches": 'https://api.redoc.ly/registry/**',
+      "name": "Authorization",
+      "envVariable": undefined,
+      "value": "accessToken"
+    }, {
+      "matches": 'https://api.redocly.com/registry/**',
+      "name": "Authorization",
+      "envVariable": undefined,
+      "value": "accessToken"
+    }]);
+  });
+
+  it('should resolve config http header by EU region', async () => {
+    jest.spyOn(RedoclyClient.prototype, 'getTokens').mockImplementation(
+      () => Promise.resolve([{ region: 'eu', token: "accessToken", valid: true }])
+    );
+    const config = await loadConfig();
+    expect(config.resolve.http.headers).toStrictEqual([{
+      "matches": 'https://api.eu.redocly.com/registry/**',
+      "name": "Authorization",
+      "envVariable": undefined,
+      "value": "accessToken"
+    }]);
+  });
+});

package/src/config/all.ts

@@ -38,6 +38,8 @@ export 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/src/config/config.ts

@@ -123,11 +123,26 @@ export type ResolveConfig = {
   http: HttpResolveConfig;
 };
 
+export const DEFAULT_REGION = 'us';
+export type Region = 'us' | 'eu';
+export type AccessTokens = {[region in Region]?: string };
+const REDOCLY_DOMAIN = process.env.REDOCLY_DOMAIN;
+export const DOMAINS: { [region in Region]: string } = {
+  us: 'redoc.ly',
+  eu: 'eu.redocly.com',
+};
+
+// FIXME: temporary fix for our lab environments
+if (REDOCLY_DOMAIN?.endsWith('.redocly.host')) {
+  DOMAINS[REDOCLY_DOMAIN.split('.')[0] as Region] = REDOCLY_DOMAIN;
+}
+
 export type RawConfig = {
   referenceDocs?: any;
   apiDefinitions?: Record<string, string>;
   lint?: LintRawConfig;
   resolve?: RawResolveConfig;
+  region?: Region;
 };
 
 export class LintConfig {
@@ -385,6 +400,7 @@ export class Config {
   lint: LintConfig;
   resolve: ResolveConfig;
   licenseKey?: string;
+  region?: Region;
   constructor(public rawConfig: RawConfig, public configFile?: string) {
     this.apiDefinitions = rawConfig.apiDefinitions || {};
     this.lint = new LintConfig(rawConfig.lint || {}, configFile);
@@ -395,6 +411,7 @@ export class Config {
         customFetch: undefined,
       },
     };
+    this.region = rawConfig.region;
   }
 }
 

package/src/config/load.ts

@@ -1,8 +1,7 @@
 import * as fs from 'fs';
-
 import { RedoclyClient } from '../redocly';
 import { loadYaml } from '../utils';
-import { Config, RawConfig } from './config';
+import { Config, DOMAINS, RawConfig, Region } from './config';
 
 import { defaultPlugin } from './builtIn';
 
@@ -25,19 +24,31 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
   }
 
   const redoclyClient = new RedoclyClient();
-  if (redoclyClient.hasToken()) {
+  const tokens = await 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 = [...(rawConfig.resolve.http.headers ?? [])];
+
+    for (const item of tokens) {
+      const domain = DOMAINS[item.region as Region];
+      rawConfig.resolve.http.headers.push({
+        matches: `https://api.${domain}/registry/**`,
         name: 'Authorization',
         envVariable: undefined,
-        value: (redoclyClient && (await redoclyClient.getAuthorizationHeader())) || '',
+        value: item.token,
       },
-      ...(rawConfig.resolve.http.headers ?? []),
-    ];
+      //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(
     {
       ...rawConfig,

package/src/index.ts

@@ -17,7 +17,7 @@ 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 {
@@ -46,11 +46,5 @@ export {
 
 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/src/redocly/__tests__/redocly-client.test.ts

@@ -0,0 +1,120 @@
+import { RedoclyClient } from '../index';
+
+describe('RedoclyClient', () => {
+  const REDOCLY_DOMAIN_US = 'redoc.ly';
+  const REDOCLY_DOMAIN_EU = 'eu.redocly.com';
+  const REDOCLY_AUTHORIZATION_TOKEN = 'redocly-auth-token';
+  const testRedoclyDomain = 'redoclyDomain.com';
+  const testToken = 'test-token';
+
+  afterEach(() => {
+    delete process.env.REDOCLY_DOMAIN;
+  });
+
+  it('should resolve the US domain by default', () => {
+    const client = new RedoclyClient();
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve domain from RedoclyDomain env', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient();
+    expect(client.domain).toBe(testRedoclyDomain);
+  });
+
+  it('should resolve a domain by US region', () => {
+    const client = new RedoclyClient('us');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve a domain by EU region', () => {
+    const client = new RedoclyClient('eu');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
+  });
+
+  it('should resolve domain by EU region prioritizing flag over env variable', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient('eu');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
+  });
+
+  it('should resolve domain by US region prioritizing flag over env variable', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient('us');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve domain by US region when REDOCLY_DOMAIN consists EU domain', () => {
+    process.env.REDOCLY_DOMAIN = REDOCLY_DOMAIN_EU;
+    const client = new RedoclyClient();
+    expect(client.getRegion()).toBe('eu');
+  });
+
+  it('should resolve valid tokens data', async () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
+      return { us: "accessToken", eu: "eu-accessToken" }
+    });
+    const client = new RedoclyClient();
+    const tokens = await client.getValidTokens();
+    expect(tokens).toStrictEqual([
+      { region: 'us', token: 'accessToken', valid: true },
+      { region: 'eu', token: 'eu-accessToken', valid: true }
+    ]);
+    spy.mockRestore();
+  });
+
+  it('should not call setAccessTokens by default', () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({}));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).not.toHaveBeenCalled()
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - backward compatibility: default US region', () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).toBeCalledWith(
+      expect.objectContaining({ us: testToken })
+    );
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - backward compatibility: EU region', () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient('eu');
+    expect(client.setAccessTokens).toBeCalledWith(
+      expect.objectContaining({ eu: testToken })
+    );
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - REDOCLY_AUTHORIZATION env', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation();
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { "us": REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over token in file', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "us": REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over EU token', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ us: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient('eu');
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "eu": REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+});

package/src/redocly/index.ts

@@ -1,50 +1,61 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
-import { yellow, red, green, gray } from 'colorette';
+import { red, green, gray, yellow } from 'colorette';
 import { RegistryApi } from './registry-api';
+import { AccessTokens, DEFAULT_REGION, DOMAINS, Region } from '../config/config';
+import { isNotEmptyObject } from '../utils';
 
 const TOKEN_FILENAME = '.redocly-config.json';
 
 export class RedoclyClient {
-  private accessToken: string | undefined;
+  private accessTokens: AccessTokens = {};
+  private region: Region;
+  domain: string;
   registryApi: RegistryApi;
 
-  constructor() {
-    this.loadToken();
-    this.registryApi = new RegistryApi(this.accessToken);
+  constructor(region?: Region) {
+    this.region = this.loadRegion(region);
+    this.loadTokens();
+    this.domain = region
+      ? DOMAINS[region]
+      : process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+    this.registryApi = new RegistryApi(this.accessTokens, this.region);
   }
 
-  hasToken(): boolean {
-    return !!this.accessToken;
-  }
-
-  loadToken(): void {
-    if (process.env.REDOCLY_AUTHORIZATION) {
-      this.accessToken = process.env.REDOCLY_AUTHORIZATION;
-      return;
+  loadRegion(region?: Region) {
+    if (region && !DOMAINS[region]) {
+      process.stdout.write(
+        red(`Invalid argument: region in config file.\nGiven: ${green(region)}, choices: "us", "eu".\n`),
+      );
+      process.exit(1);
     }
 
-    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-    if (existsSync(credentialsPath)) {
-      const credentials = JSON.parse(readFileSync(credentialsPath, 'utf-8'));
-      this.accessToken = credentials && credentials.token;
+    if (process.env.REDOCLY_DOMAIN) {
+      return (Object.keys(DOMAINS).find(
+        (region) => DOMAINS[region as Region] === process.env.REDOCLY_DOMAIN,
+      ) || DEFAULT_REGION) as Region;
     }
+    return region || DEFAULT_REGION;
   }
 
-  async isAuthorizedWithRedocly(): Promise<boolean> {
-    return this.hasToken() && !!(await this.getAuthorizationHeader());
+  getRegion(): Region {
+    return this.region;
   }
 
-  async verifyToken(accessToken: string, verbose: boolean = false): Promise<boolean> {
-    if (!accessToken) return false;
+  hasTokens(): boolean {
+    return isNotEmptyObject(this.accessTokens);
+  }
 
-    return this.registryApi.setAccessToken(accessToken).authStatus(verbose);
+  // <backward compatibility: old versions of portal>
+  hasToken() {
+    return !!this.accessTokens[this.region];
   }
 
   async getAuthorizationHeader(): Promise<string | undefined> {
+    const token = this.accessTokens[this.region];
     // print this only if there is token but invalid
-    if (this.accessToken && !(await this.verifyToken(this.accessToken))) {
+    if (token && !this.isAuthorizedWithRedoclyByRegion()) {
       process.stderr.write(
         `${yellow(
           'Warning:',
@@ -52,15 +63,74 @@ export class RedoclyClient {
       );
       return undefined;
     }
-    return this.accessToken;
+
+    return token;
+  }
+  // </backward compatibility: portal>
+
+  setAccessTokens(accessTokens: AccessTokens) {
+    this.accessTokens = accessTokens;
+  }
+
+  loadTokens(): void {
+    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
+    const credentials = this.readCredentialsFile(credentialsPath);
+    if (isNotEmptyObject(credentials)) {
+      this.setAccessTokens({
+        ...credentials,
+        ...(credentials.token && !credentials[this.region] && {
+          [this.region]: credentials.token
+        })
+      })
+    }
+    if (process.env.REDOCLY_AUTHORIZATION) {
+      this.setAccessTokens({
+        ...this.accessTokens,
+        [this.region]: process.env.REDOCLY_AUTHORIZATION
+      })
+    }
+  }
+
+  async getValidTokens(): Promise<{
+    region: string;
+    token: string;
+    valid: boolean;
+  }[]> {
+    return (await Promise.all(
+      Object.entries(this.accessTokens).map(async ([key, value]) => {
+        return { region: key, token: value, valid: await this.verifyToken(value, key as Region) }
+      })
+    )).filter(item => Boolean(item.valid));
+  }
+
+  async getTokens() {
+    return this.hasTokens() ? await this.getValidTokens() : [];
+  }
+
+  async isAuthorizedWithRedoclyByRegion(): Promise<boolean> {
+    if (!this.hasTokens()) return false;
+    const accessToken = this.accessTokens[this.region];
+    return !!accessToken && await this.verifyToken(accessToken, this.region);
+  }
+
+  async isAuthorizedWithRedocly(): Promise<boolean> {
+    return this.hasTokens() && isNotEmptyObject(await this.getValidTokens());
+  }
+
+  readCredentialsFile(credentialsPath: string) {
+    return existsSync(credentialsPath) ? JSON.parse(readFileSync(credentialsPath, 'utf-8')) : {};
+  }
+
+  async verifyToken(accessToken: string, region: Region, verbose: boolean = false): Promise<boolean> {
+    if (!accessToken) return false;
+    return this.registryApi.authStatus(accessToken, region, verbose);
   }
 
   async login(accessToken: string, verbose: boolean = false) {
     const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
     process.stdout.write(gray('\n  Logging in...\n'));
 
-    const authorized = await this.verifyToken(accessToken, verbose);
-
+    const authorized = await this.verifyToken(accessToken, this.region, verbose);
     if (!authorized) {
       process.stdout.write(
         red('Authorization failed. Please check if you entered a valid API key.\n'),
@@ -68,11 +138,13 @@ export class RedoclyClient {
       process.exit(1);
     }
 
-    this.accessToken = accessToken;
     const credentials = {
-      token: accessToken,
+      ...this.readCredentialsFile(credentialsPath),
+      [this.region!]: accessToken,
+      token: accessToken, // FIXME: backward compatibility, remove on 1.0.0
     };
-
+    this.accessTokens = credentials;
+    this.registryApi.setAccessTokens(credentials);
     writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
     process.stdout.write(green('  Authorization confirmed. ✅\n\n'));
   }
@@ -87,7 +159,7 @@ export class RedoclyClient {
 }
 
 export function isRedoclyRegistryURL(link: string): boolean {
-  const domain = process.env.REDOCLY_DOMAIN || 'redoc.ly';
+  const domain = process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
   if (!link.startsWith(`https://api.${domain}/registry/`)) return false;
   const registryPath = link.replace(`https://api.${domain}/registry/`, '');
 

package/src/redocly/registry-api.ts

@@ -1,45 +1,40 @@
-import fetch, { RequestInit } from 'node-fetch';
+import fetch, { RequestInit, HeadersInit } from 'node-fetch';
 import { RegistryApiTypes } from './registry-api-types';
+import { AccessTokens, Region, DEFAULT_REGION, DOMAINS } from '../config/config';
+import { isNotEmptyObject } from '../utils';
 const version = require('../../package.json').version;
 
 export class RegistryApi {
-  private readonly baseUrl = `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry`;
+  constructor(private accessTokens: AccessTokens, private region: Region) {}
 
-  constructor(private accessToken?: string) {}
-
-  private async request(path = '', options: RequestInit = {}) {
-    if (!this.accessToken) {
-      throw new Error('Unauthorized');
-    }
-
-    const headers = Object.assign({}, options.headers || {}, {
-      authorization: this.accessToken,
-      'x-redocly-cli-version': version,
-    });
+  get accessToken() {
+    return isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
+  }
 
-    const response = await fetch(`${this.baseUrl}${path}`, Object.assign({}, options, { headers }));
+  getBaseUrl(region: Region = DEFAULT_REGION) {
+    return `https://api.${DOMAINS[region]}/registry`;
+  }
 
-    if (response.status === 401) {
-      throw new Error('Unauthorized');
-    }
+  setAccessTokens(accessTokens: AccessTokens) {
+    this.accessTokens = accessTokens;
+    return this;
+  }
 
+  private async request(path = '', options: RequestInit = {}, region?: Region) {
+    const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
+    if (!headers.hasOwnProperty('authorization')) { throw new Error('Unauthorized'); }
+    const response = await fetch(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
+    if (response.status === 401) { throw new Error('Unauthorized'); }
     if (response.status === 404) {
       const body: RegistryApiTypes.NotFoundProblemResponse = await response.json();
       throw new Error(body.code);
     }
-
     return response;
   }
 
-  setAccessToken(accessToken: string) {
-    this.accessToken = accessToken;
-    return this;
-  }
-
-  async authStatus(verbose = false) {
+  async authStatus(accessToken: string, region: Region, verbose = false) {
     try {
-      const response = await this.request();
-
+      const response = await this.request('', { headers: { authorization: accessToken }}, region);
       return response.ok;
     } catch (error) {
       if (verbose) {
@@ -61,13 +56,17 @@ export class RegistryApi {
       `/${organizationId}/${name}/${version}/prepare-file-upload`,
       {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
+        headers: {
+          'content-type': 'application/json',
+          authorization: this.accessToken,
+        } as HeadersInit,
         body: JSON.stringify({
           filesHash,
           filename,
           isUpsert,
         }),
       },
+      this.region
     );
 
     if (response.ok) {
@@ -88,14 +87,19 @@ export class RegistryApi {
   }: RegistryApiTypes.PushApiParams) {
     const response = await this.request(`/${organizationId}/${name}/${version}`, {
       method: 'PUT',
-      headers: { 'content-type': 'application/json' },
+      headers: {
+        'content-type': 'application/json',
+        authorization: this.accessToken
+      } as HeadersInit,
       body: JSON.stringify({
         rootFilePath,
         filePaths,
         branch,
         isUpsert,
       }),
-    });
+    },
+      this.region
+    );
 
     if (response.ok) {
       return;