@redocly/openapi-core 1.0.0-beta.68 → 1.0.0-beta.72

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/lint.ts

@@ -72,6 +72,7 @@ export async function lintDocument(opts: {
   const ctx: WalkContext = {
     problems: [],
     oasVersion: oasVersion,
+    visitorsData: {},
   };
 
   const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
@@ -101,6 +102,7 @@ export async function lintConfig(opts: {
   const ctx: WalkContext = {
     problems: [],
     oasVersion: OasVersion.Version3_0,
+    visitorsData: {},
   };
   const config = new LintConfig({
     plugins: [defaultPlugin],

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,65 +1,115 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
-import { yellow, red, green, gray } from 'colorette';
-import { query } from './query';
+import { red, green, gray } 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(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);
+  }
+
+  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);
+    }
 
-  constructor() {
-    this.loadToken();
+    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;
   }
 
-  hasToken(): boolean {
-    return !!this.accessToken;
+  getRegion(): Region {
+    return this.region;
   }
 
-  loadToken(): void {
-    if (process.env.REDOCLY_AUTHORIZATION) {
-      this.accessToken = process.env.REDOCLY_AUTHORIZATION;
-      return;
-    }
+  hasTokens(): boolean {
+    return isNotEmptyObject(this.accessTokens);
+  }
+
+  setAccessTokens(accessTokens: AccessTokens) {
+    this.accessTokens = accessTokens;
+  }
 
+  loadTokens(): void {
     const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-    if (existsSync(credentialsPath)) {
-      const credentials = JSON.parse(readFileSync(credentialsPath, 'utf-8'));
-      this.accessToken = credentials && credentials.token;
+    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.hasToken() && !!(await this.getAuthorizationHeader());
+    return this.hasTokens() && isNotEmptyObject(await this.getValidTokens());
   }
 
-  async verifyToken(accessToken: string, verbose: boolean = false): Promise<boolean> {
-    if (!accessToken) return false;
-    const authDetails = await RedoclyClient.authorize(accessToken, { verbose });
-    if (!authDetails) return false;
-    return true;
+  readCredentialsFile(credentialsPath: string) {
+    return existsSync(credentialsPath) ? JSON.parse(readFileSync(credentialsPath, 'utf-8')) : {};
   }
 
-  async getAuthorizationHeader(): Promise<string | undefined> {
-    // print this only if there is token but invalid
-    if (this.accessToken && !(await this.verifyToken(this.accessToken))) {
-      process.stderr.write(
-        `${yellow(
-          'Warning:',
-        )} invalid Redocly API key. Use "npx @redocly/openapi-cli login" to provide your API key\n`,
-      );
-      return undefined;
-    }
-    return this.accessToken;
+  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'),
@@ -67,11 +117,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'));
   }
@@ -83,198 +135,20 @@ export class RedoclyClient {
     }
     process.stdout.write('Logged out from the Redocly account. ✋\n');
   }
+}
 
-  async query(queryString: string, parameters = {}, headers = {}) {
-    return query(queryString, parameters, {
-      Authorization: this.accessToken,
-      ...headers,
-    });
-  }
-
-  static async authorize(accessToken: string, options: { queryName?: string; verbose?: boolean }) {
-    const { queryName = '', verbose = false } = options;
-    try {
-      const queryStr = `query ${queryName}{ viewer { id } }`;
-
-      return await query(queryStr, {}, { Authorization: accessToken });
-    } catch (e) {
-      if (verbose) console.log(e);
-      return null;
-    }
-  }
-
-  async updateDependencies(dependencies: string[] | undefined): Promise<void> {
-    const definitionId = process.env.DEFINITION;
-    const versionId = process.env.DEFINITION;
-    const branchId = process.env.BRANCH;
-
-    if (!definitionId || !versionId || !branchId) return;
-
-    await 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: number, versionId: number, updatePatch: object): Promise<void> {
-    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: string) {
-    return this.query(`
-      query ($organizationId: String!) {
-        organizationById(id: $organizationId) {
-          id
-        }
-      }
-    `, {
-      organizationId
-    });
-  }
-
-  getDefinitionByName(name: string, organizationId: string) {
-    return this.query(`
-      query ($name: String!, $organizationId: String!) {
-        definition: definitionByOrganizationIdAndName(name: $name, organizationId: $organizationId) {
-          id
-        }
-      }
-    `, {
-      name,
-      organizationId
-    });
-  }
-
-  createDefinition(organizationId: string, name: string) {
-    return this.query(`
-      mutation CreateDefinition($organizationId: String!, $name: String!) {
-        def: createDefinition(input: {organizationId: $organizationId, name: $name }) {
-          definition {
-            id
-            nodeId
-            name
-          }
-        }
-      }
-    `, {
-      organizationId,
-      name
-    })
-  }
-
-  createDefinitionVersion(definitionId: string, name: string, sourceType: string, source: any) {
-    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: string, filesHash: string, fileName: string) {
-    return this.query(`
-      query ($organizationId: String!, $filesHash: String!, $fileName: String!) {
-        signFileUploadCLI(organizationId: $organizationId, filesHash: $filesHash, fileName: $fileName) {
-          signedFileUrl
-          uploadedFilePath
-        }
-      }
-    `, {
-      organizationId,
-      filesHash,
-      fileName
-    })
-  }
-
-  getDefinitionVersion(organizationId: string, definitionName: string, versionName: string) {
-    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: string): boolean {
-    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/`, '');
+export function isRedoclyRegistryURL(link: string): boolean {
+  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/`, '');
 
-    const pathParts = registryPath.split('/');
+  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;
+  // 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;
-  }
+  return true;
 }

package/src/redocly/registry-api-types.ts

@@ -0,0 +1,31 @@
+export 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';
+  }
+}