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

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

@@ -2,15 +2,17 @@ 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 { RegistryApi } from './registry-api';
 
 const TOKEN_FILENAME = '.redocly-config.json';
 
 export class RedoclyClient {
   private accessToken: string | undefined;
+  registryApi: RegistryApi;
 
   constructor() {
     this.loadToken();
+    this.registryApi = new RegistryApi(this.accessToken);
   }
 
   hasToken(): boolean {
@@ -36,9 +38,8 @@ export class RedoclyClient {
 
   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;
+
+    return this.registryApi.setAccessToken(accessToken).authStatus(verbose);
   }
 
   async getAuthorizationHeader(): Promise<string | undefined> {
@@ -83,198 +84,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 || 'redoc.ly';
+  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,106 @@
+import fetch, { RequestInit } from 'node-fetch';
+import { RegistryApiTypes } from './registry-api-types';
+const version = require('../../package.json').version;
+
+export class RegistryApi {
+  private readonly baseUrl = `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry`;
+
+  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,
+    });
+
+    const response = await fetch(`${this.baseUrl}${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) {
+    try {
+      const response = await this.request();
+
+      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' },
+        body: JSON.stringify({
+          filesHash,
+          filename,
+          isUpsert,
+        }),
+      },
+    );
+
+    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' },
+      body: JSON.stringify({
+        rootFilePath,
+        filePaths,
+        branch,
+        isUpsert,
+      }),
+    });
+
+    if (response.ok) {
+      return;
+    }
+
+    throw new Error('Could not push api');
+  }
+}

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

@@ -33,6 +33,7 @@ export type UserContext = {
   key: string | number;
   parent: any;
   oasVersion: OasVersion;
+  getVisitorData: () => Record<string, unknown>;
 };
 
 export type Loc = {
@@ -77,6 +78,7 @@ export type NormalizedProblem = {
 export type WalkContext = {
   problems: NormalizedProblem[];
   oasVersion: OasVersion;
+  visitorsData: Record<string, Record<string, unknown>>; // custom data store that visitors can use for various purposes
   refTypes?: Map<string, NormalizedNodeType>;
 };
 
@@ -141,6 +143,7 @@ export function walkDocument<T>(opts: {
               key,
               parentLocations: {},
               oasVersion: ctx.oasVersion,
+              getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
             },
             { node: resolvedNode, location: resolvedLocation, error },
           );
@@ -325,6 +328,7 @@ export function walkDocument<T>(opts: {
               key,
               parentLocations: {},
               oasVersion: ctx.oasVersion,
+              getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
             },
             { node: resolvedNode, location: resolvedLocation, error },
           );
@@ -357,6 +361,7 @@ export function walkDocument<T>(opts: {
           ignoreNextVisitorsOnNode: () => {
             ignoreNextVisitorsOnNode = true;
           },
+          getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
         },
         collectParents(context),
         context,
@@ -408,5 +413,10 @@ export function walkDocument<T>(opts: {
         }),
       });
     }
+
+    function getVisitorDataFn(ruleId: string) {
+      ctx.visitorsData[ruleId] = ctx.visitorsData[ruleId] || {};
+      return ctx.visitorsData[ruleId];
+    }
   }
 }