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

package/src/redocly/__tests__/redocly-client.test.ts

@@ -0,0 +1,114 @@
+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 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,105 @@
 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);
+    }
+    return region || DEFAULT_REGION;
+  }
 
-  constructor() {
-    this.loadToken();
+  hasTokens(): boolean {
+    return isNotEmptyObject(this.accessTokens);
   }
 
-  hasToken(): boolean {
-    return !!this.accessToken;
+  setAccessTokens(accessTokens: AccessTokens) {
+    this.accessTokens = accessTokens;
   }
 
-  loadToken(): void {
+  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.accessToken = process.env.REDOCLY_AUTHORIZATION;
-      return;
+      this.setAccessTokens({
+        ...this.accessTokens,
+        [this.region]: process.env.REDOCLY_AUTHORIZATION
+      })
     }
+  }
 
-    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-    if (existsSync(credentialsPath)) {
-      const credentials = JSON.parse(readFileSync(credentialsPath, 'utf-8'));
-      this.accessToken = credentials && credentials.token;
-    }
+  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 +107,12 @@ export class RedoclyClient {
       process.exit(1);
     }
 
-    this.accessToken = accessToken;
     const credentials = {
-      token: accessToken,
+      ...this.readCredentialsFile(credentialsPath),
+      [this.region!]: accessToken,
     };
-
+    this.accessTokens = credentials;
+    this.registryApi.setAccessTokens(credentials);
     writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
     process.stdout.write(green('  Authorization confirmed. ✅\n\n'));
   }
@@ -83,198 +124,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';
+  }
+}

package/src/redocly/registry-api.ts

@@ -0,0 +1,110 @@
+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 {
+  constructor(private accessTokens: AccessTokens, private region: Region) {}
+
+  get accessToken() {
+    return isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
+  }
+
+  getBaseUrl(region: Region = DEFAULT_REGION) {
+    return `https://api.${DOMAINS[region]}/registry`;
+  }
+
+  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;
+  }
+
+  async authStatus(accessToken: string, region: Region, verbose = false) {
+    try {
+      const response = await this.request('', { headers: { authorization: accessToken }}, region);
+      return response.ok;
+    } catch (error) {
+      if (verbose) {
+        console.log(error);
+      }
+      return false;
+    }
+  }
+
+  async prepareFileUpload({
+    organizationId,
+    name,
+    version,
+    filesHash,
+    filename,
+    isUpsert,
+  }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse> {
+    const response = await this.request(
+      `/${organizationId}/${name}/${version}/prepare-file-upload`,
+      {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          authorization: this.accessToken,
+        } as HeadersInit,
+        body: JSON.stringify({
+          filesHash,
+          filename,
+          isUpsert,
+        }),
+      },
+      this.region
+    );
+
+    if (response.ok) {
+      return response.json();
+    }
+
+    throw new Error('Could not prepare file upload');
+  }
+
+  async pushApi({
+    organizationId,
+    name,
+    version,
+    rootFilePath,
+    filePaths,
+    branch,
+    isUpsert,
+  }: RegistryApiTypes.PushApiParams) {
+    const response = await this.request(`/${organizationId}/${name}/${version}`, {
+      method: 'PUT',
+      headers: {
+        'content-type': 'application/json',
+        authorization: this.accessToken
+      } as HeadersInit,
+      body: JSON.stringify({
+        rootFilePath,
+        filePaths,
+        branch,
+        isUpsert,
+      }),
+    },
+      this.region
+    );
+
+    if (response.ok) {
+      return;
+    }
+
+    throw new Error('Could not push api');
+  }
+}

package/src/ref-utils.ts

@@ -1,5 +1,3 @@
-import { sep as platformDependentSeparator } from 'path';
-
 import { Source } from './resolve';
 import { OasRef } from './typings/openapi';
 
@@ -61,7 +59,7 @@ export function pointerBaseName(pointer: string) {
 }
 
 export function refBaseName(ref: string) {
-  const parts = ref.split(platformDependentSeparator);
+  const parts = ref.split(/[\/\\]/); // split by '\' and '/'
   return parts[parts.length - 1].split('.')[0];
 }