@redocly/openapi-core 1.0.0-beta.67 → 1.0.0-beta.71

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,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 +134,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];
 }
 

package/src/rules/common/__tests__/paths-kebab-case.test.ts

@@ -83,4 +83,27 @@ describe('Oas3 paths-kebab-case', () => {
       ]
     `);
   });
+
+  it('should allow trailing slash in path with "paths-kebab-case" rule', async () => {
+      const document = parseYamlToDocument(
+        outdent`
+            openapi: 3.0.0
+            paths:
+              /some/:
+                get:
+                  summary: List all pets
+          `,
+        'foobar.yaml',
+      );
+
+      const results = await lintDocument({
+        externalRefResolver: new BaseResolver(),
+        document,
+        config: makeConfig({
+          'paths-kebab-case': 'error',
+          'no-path-trailing-slash': 'off',
+        }),
+      });
+      expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+    });
 });

package/src/rules/common/no-invalid-parameter-examples.ts

@@ -0,0 +1,36 @@
+import { UserContext } from '../../walk';
+import { Oas3Parameter } from '../../typings/openapi';
+import { validateExample } from '../utils';
+
+export const NoInvalidParameterExamples: any = (opts: any) => {
+  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
+  return {
+    Parameter: {
+      leave(parameter: Oas3Parameter, ctx: UserContext) {
+        if (parameter.example) {
+          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) {
+              validateExample(
+                example.value,
+                parameter.schema!,
+                ctx.location.child(['examples', key]),
+                ctx,
+                false,
+              );
+            }
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/common/no-invalid-schema-examples.ts

@@ -0,0 +1,27 @@
+import { UserContext } from '../../walk';
+import { Oas3_1Schema } from '../../typings/openapi';
+import { validateExample } from '../utils';
+
+export const NoInvalidSchemaExamples: any = (opts: any) => {
+  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
+  return {
+    Schema: {
+      leave(schema: Oas3_1Schema, ctx: UserContext) {
+        if (schema.examples) {
+          for (const example of schema.examples) {
+            validateExample(
+              example,
+              schema,
+              ctx.location.child(['examples', schema.examples.indexOf(example)]),
+              ctx,
+              disallowAdditionalProperties,
+            );
+          }
+        }
+        if (schema.example) {
+          validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
+        }
+      },
+    },
+  };
+};

package/src/rules/common/paths-kebab-case.ts

@@ -4,7 +4,7 @@ import { UserContext } from '../../walk';
 export const PathsKebabCase: Oas3Rule | Oas2Rule = () => {
   return {
     PathItem(_path: object, { report, key }: UserContext) {
-      const segments = (key as string).substr(1).split('/');
+      const segments = (key as string).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/src/rules/common/registry-dependencies.ts

@@ -1,24 +1,22 @@
-import { RedoclyClient } from '../../redocly';
+import { UserContext } from '../../walk';
+import { isRedoclyRegistryURL } from '../../redocly';
 
 import { Oas3Decorator, Oas2Decorator } from '../../visitors';
 
 export const RegistryDependencies: Oas3Decorator | Oas2Decorator = () => {
-  let redoclyClient: RedoclyClient;
   let registryDependencies = new Set<string>();
 
   return {
     DefinitionRoot: {
-      leave() {
-        redoclyClient = new RedoclyClient();
-        if (process.env.UPDATE_REGISTRY && redoclyClient.hasToken()) {
-          redoclyClient.updateDependencies(Array.from(registryDependencies.keys()));
-        }
+      leave(_: any, ctx: UserContext) {
+        const data = ctx.getVisitorData();
+        data.links = Array.from(registryDependencies);
       },
     },
     ref(node) {
       if (node.$ref) {
         const link = node.$ref.split('#/')[0];
-        if (RedoclyClient.isRegistryURL(link)) {
+        if (isRedoclyRegistryURL(link)) {
           registryDependencies.add(link);
         }
       }

package/src/rules/oas2/index.ts

@@ -1,4 +1,6 @@
 import { OasSpec } from '../common/spec';
+import { NoInvalidSchemaExamples } from '../common/no-invalid-schema-examples';
+import { NoInvalidParameterExamples } from '../common/no-invalid-parameter-examples';
 import { InfoDescription } from '../common/info-description';
 import { InfoContact } from '../common/info-contact';
 import { InfoLicense } from '../common/info-license-url';
@@ -41,6 +43,8 @@ import { InfoDescriptionOverride } from '../common/info-description-override';
 
 export const rules = {
   spec: OasSpec as Oas2Rule,
+  'no-invalid-schema-examples': NoInvalidSchemaExamples,
+  'no-invalid-parameter-examples': NoInvalidParameterExamples,
   'info-description': InfoDescription as Oas2Rule,
   'info-contact': InfoContact as Oas2Rule,
   'info-license': InfoLicense as Oas2Rule,