@redocly/cli 1.7.0 → 1.8.0

package/src/__tests__/commands/push-region.test.ts

@@ -12,7 +12,7 @@ jest.mock('node-fetch', () => ({
 }));
 jest.mock('@redocly/openapi-core');
 jest.mock('../../commands/login');
-jest.mock('../../utils');
+jest.mock('../../utils/miscellaneous');
 
 (getMergedConfig as jest.Mock).mockImplementation((config) => config);
 

package/src/__tests__/commands/push.test.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import { Config, getMergedConfig } from '@redocly/openapi-core';
-import { exitWithError } from '../../utils';
+import { exitWithError } from '../../utils/miscellaneous';
 import { getApiRoot, getDestinationProps, handlePush, transformPush } from '../../commands/push';
 import { ConfigFixture } from '../fixtures/config';
 import { yellow } from 'colorette';
@@ -13,7 +13,7 @@ jest.mock('node-fetch', () => ({
   })),
 }));
 jest.mock('@redocly/openapi-core');
-jest.mock('../../utils');
+jest.mock('../../utils/miscellaneous');
 
 (getMergedConfig as jest.Mock).mockImplementation((config) => config);
 

package/src/__tests__/fetch-with-timeout.test.ts

@@ -1,4 +1,5 @@
-import fetchWithTimeout from '../fetch-with-timeout';
+import AbortController from 'abort-controller';
+import fetchWithTimeout from '../utils/fetch-with-timeout';
 import nodeFetch from 'node-fetch';
 
 jest.mock('node-fetch');
@@ -8,20 +9,7 @@ describe('fetchWithTimeout', () => {
     jest.clearAllMocks();
   });
 
-  it('should use bare node-fetch if AbortController is not available', async () => {
-    // @ts-ignore
-    global.AbortController = undefined;
-    // @ts-ignore
-    global.setTimeout = jest.fn();
-    await fetchWithTimeout('url', { method: 'GET' });
-
-    expect(nodeFetch).toHaveBeenCalledWith('url', { method: 'GET' });
-
-    expect(global.setTimeout).toHaveBeenCalledTimes(0);
-  });
-
-  it('should call node-fetch with signal if AbortController is  available', async () => {
-    global.AbortController = jest.fn().mockImplementation(() => ({ signal: 'something' }));
+  it('should call node-fetch with signal', async () => {
     // @ts-ignore
     global.setTimeout = jest.fn();
 
@@ -29,7 +17,7 @@ describe('fetchWithTimeout', () => {
     await fetchWithTimeout('url');
 
     expect(global.setTimeout).toHaveBeenCalledTimes(1);
-    expect(nodeFetch).toHaveBeenCalledWith('url', { signal: 'something' });
+    expect(nodeFetch).toHaveBeenCalledWith('url', { signal: new AbortController().signal });
     expect(global.clearTimeout).toHaveBeenCalledTimes(1);
   });
 });

package/src/__tests__/spinner.test.ts

@@ -0,0 +1,51 @@
+import { Spinner } from '../utils/spinner';
+import * as process from 'process';
+
+jest.useFakeTimers();
+
+describe('Spinner', () => {
+  const IS_TTY = process.stdout.isTTY;
+
+  let writeMock: jest.SpyInstance;
+  let spinner: Spinner;
+
+  beforeEach(() => {
+    process.stdout.isTTY = true;
+    writeMock = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+    spinner = new Spinner();
+  });
+
+  afterEach(() => {
+    writeMock.mockRestore();
+    jest.clearAllTimers();
+  });
+
+  afterAll(() => {
+    process.stdout.isTTY = IS_TTY;
+  });
+
+  it('starts the spinner', () => {
+    spinner.start('Loading');
+    jest.advanceTimersByTime(100);
+    expect(writeMock).toHaveBeenCalledWith('\r⠋ Loading');
+  });
+
+  it('stops the spinner', () => {
+    spinner.start('Loading');
+    spinner.stop();
+    expect(writeMock).toHaveBeenCalledWith('\r');
+  });
+
+  it('should write 3 frames', () => {
+    spinner.start('Loading');
+    jest.advanceTimersByTime(300);
+    expect(writeMock).toHaveBeenCalledTimes(3);
+  });
+
+  it('should call write 1 times if CI set to true', () => {
+    process.stdout.isTTY = false;
+    spinner.start('Loading');
+    jest.advanceTimersByTime(300);
+    expect(writeMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/utils.test.ts

@@ -13,10 +13,8 @@ import {
   cleanArgs,
   cleanRawInput,
   getAndValidateFileExtension,
-  writeYaml,
-  writeJson,
   writeToFileByExtension,
-} from '../utils';
+} from '../utils/miscellaneous';
 import {
   ResolvedApi,
   Totals,
@@ -26,10 +24,9 @@ import {
   stringifyYaml,
 } from '@redocly/openapi-core';
 import { blue, red, yellow } from 'colorette';
-import { existsSync, statSync, writeFileSync } from 'fs';
+import { existsSync, statSync } from 'fs';
 import * as path from 'path';
 import * as process from 'process';
-import * as utils from '../utils';
 
 jest.mock('os');
 jest.mock('colorette');

package/src/__tests__/wrapper.test.ts

@@ -1,4 +1,4 @@
-import { loadConfigAndHandleErrors, sendTelemetry } from '../utils';
+import { loadConfigAndHandleErrors, sendTelemetry } from '../utils/miscellaneous';
 import * as process from 'process';
 import { commandWrapper } from '../wrapper';
 import { handleLint } from '../commands/lint';
@@ -6,7 +6,7 @@ import { Arguments } from 'yargs';
 import { handlePush, PushOptions } from '../commands/push';
 
 jest.mock('node-fetch');
-jest.mock('../utils', () => ({
+jest.mock('../utils/miscellaneous', () => ({
   sendTelemetry: jest.fn(),
   loadConfigAndHandleErrors: jest.fn(),
 }));

package/src/cms/api/__tests__/api-keys.test.ts

@@ -0,0 +1,37 @@
+import { getApiKeys } from '../api-keys';
+import * as fs from 'fs';
+
+describe('getApiKeys()', () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should return api key from environment variable', () => {
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    expect(getApiKeys('test-domain')).toEqual('test-api-key');
+  });
+
+  it('should return api key from credentials file', () => {
+    process.env.REDOCLY_AUTHORIZATION = '';
+
+    jest.spyOn(fs, 'existsSync').mockReturnValue(true);
+    jest.spyOn(fs, 'readFileSync').mockReturnValue(
+      JSON.stringify({
+        ['test-domain']: 'test-api-key-from-credentials-file',
+      })
+    );
+
+    expect(getApiKeys('test-domain')).toEqual('test-api-key-from-credentials-file');
+  });
+
+  it('should throw an error if no api key provided', () => {
+    process.env.REDOCLY_AUTHORIZATION = '';
+
+    jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+
+    expect(() => getApiKeys('test-domain')).toThrowError(
+      'No api key provided, please use environment variable REDOCLY_AUTHORIZATION.'
+    );
+  });
+});

package/src/cms/api/__tests__/api.client.test.ts

@@ -0,0 +1,275 @@
+import fetch, { Response } from 'node-fetch';
+import * as FormData from 'form-data';
+
+import { ReuniteApiClient, PushPayload } from '../api-client';
+
+jest.mock('node-fetch', () => ({
+  default: jest.fn(),
+}));
+
+function mockFetchResponse(response: any) {
+  (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValue(response as unknown as Response);
+}
+
+describe('ApiClient', () => {
+  const testToken = 'test-token';
+  const testDomain = 'test-domain.com';
+  const testOrg = 'test-org';
+  const testProject = 'test-project';
+
+  describe('getDefaultBranch()', () => {
+    let apiClient: ReuniteApiClient;
+
+    beforeEach(() => {
+      apiClient = new ReuniteApiClient(testDomain, testToken);
+    });
+
+    it('should get default project branch', async () => {
+      mockFetchResponse({
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          branchName: 'test-branch',
+        }),
+      });
+
+      const result = await apiClient.remotes.getDefaultBranch(testOrg, testProject);
+
+      expect(fetch).toHaveBeenCalledWith(
+        `${testDomain}/api/orgs/${testOrg}/projects/${testProject}/source`,
+        {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${testToken}`,
+          },
+        }
+      );
+
+      expect(result).toEqual('test-branch');
+    });
+
+    it('should throw parsed error if response is not ok', async () => {
+      mockFetchResponse({
+        ok: false,
+        json: jest.fn().mockResolvedValue({
+          type: 'about:blank',
+          title: 'Project source not found',
+          status: 404,
+          detail: 'Not Found',
+          object: 'problem',
+        }),
+      });
+
+      await expect(apiClient.remotes.getDefaultBranch(testOrg, testProject)).rejects.toThrow(
+        new Error('Failed to fetch default branch: Project source not found')
+      );
+    });
+
+    it('should throw statusText error if response is not ok', async () => {
+      mockFetchResponse({
+        ok: false,
+        statusText: 'Not found',
+        json: jest.fn().mockResolvedValue({
+          unknownField: 'unknown-error',
+        }),
+      });
+
+      await expect(apiClient.remotes.getDefaultBranch(testOrg, testProject)).rejects.toThrow(
+        new Error('Failed to fetch default branch: Not found')
+      );
+    });
+  });
+
+  describe('upsert()', () => {
+    const remotePayload = {
+      mountBranchName: 'remote-mount-branch-name',
+      mountPath: 'remote-mount-path',
+    };
+    let apiClient: ReuniteApiClient;
+
+    beforeEach(() => {
+      apiClient = new ReuniteApiClient(testDomain, testToken);
+    });
+
+    it('should upsert remote', async () => {
+      const responseMock = {
+        id: 'remote-id',
+        type: 'CICD',
+        mountPath: 'remote-mount-path',
+        mountBranchName: 'remote-mount-branch-name',
+        organizationId: testOrg,
+        projectId: testProject,
+      };
+
+      mockFetchResponse({
+        ok: true,
+        json: jest.fn().mockResolvedValue(responseMock),
+      });
+
+      const result = await apiClient.remotes.upsert(testOrg, testProject, remotePayload);
+
+      expect(fetch).toHaveBeenCalledWith(
+        `${testDomain}/api/orgs/${testOrg}/projects/${testProject}/remotes`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${testToken}`,
+          },
+          body: JSON.stringify({
+            mountPath: remotePayload.mountPath,
+            mountBranchName: remotePayload.mountBranchName,
+            type: 'CICD',
+            autoMerge: true,
+          }),
+        }
+      );
+
+      expect(result).toEqual(responseMock);
+    });
+
+    it('should throw parsed error if response is not ok', async () => {
+      mockFetchResponse({
+        ok: false,
+        json: jest.fn().mockResolvedValue({
+          type: 'about:blank',
+          title: 'Not allowed to mount remote outside of project content path: /docs',
+          status: 403,
+          detail: 'Forbidden',
+          object: 'problem',
+        }),
+      });
+
+      await expect(apiClient.remotes.upsert(testOrg, testProject, remotePayload)).rejects.toThrow(
+        new Error(
+          'Failed to upsert remote: Not allowed to mount remote outside of project content path: /docs'
+        )
+      );
+    });
+
+    it('should throw statusText error if response is not ok', async () => {
+      mockFetchResponse({
+        ok: false,
+        statusText: 'Not found',
+        json: jest.fn().mockResolvedValue({
+          unknownField: 'unknown-error',
+        }),
+      });
+
+      await expect(apiClient.remotes.upsert(testOrg, testProject, remotePayload)).rejects.toThrow(
+        new Error('Failed to upsert remote: Not found')
+      );
+    });
+  });
+
+  describe('push()', () => {
+    const testRemoteId = 'test-remote-id';
+    const pushPayload = {
+      remoteId: testRemoteId,
+      commit: {
+        message: 'test-message',
+        author: {
+          name: 'test-name',
+          email: 'test-email',
+        },
+        branchName: 'test-branch-name',
+      },
+    } as unknown as PushPayload;
+
+    const filesMock = [{ path: 'some-file.yaml', stream: Buffer.from('fefef') }];
+
+    const responseMock = {
+      branchName: 'rem/cicd/rem_01he7sr6ys2agb7w0g9t7978fn-main',
+      hasChanges: true,
+      files: [
+        {
+          type: 'file',
+          name: 'some-file.yaml',
+          path: 'docs/remotes/some-file.yaml',
+          lastModified: 1698925132394.2993,
+          mimeType: 'text/yaml',
+        },
+      ],
+      commitSha: 'bb23a2f8e012ac0b7b9961b57fb40d8686b21b43',
+      outdated: false,
+    };
+
+    let apiClient: ReuniteApiClient;
+
+    beforeEach(() => {
+      apiClient = new ReuniteApiClient(testDomain, testToken);
+    });
+
+    it('should push to remote', async () => {
+      let passedFormData = new FormData();
+
+      (fetch as jest.MockedFunction<typeof fetch>).mockImplementationOnce(
+        async (_: any, options: any): Promise<Response> => {
+          passedFormData = options.body as FormData;
+
+          return {
+            ok: true,
+            json: jest.fn().mockResolvedValue(responseMock),
+          } as unknown as Response;
+        }
+      );
+
+      const formData = new FormData();
+
+      formData.append('remoteId', testRemoteId);
+      formData.append('commit[message]', pushPayload.commit.message);
+      formData.append('commit[author][name]', pushPayload.commit.author.name);
+      formData.append('commit[author][email]', pushPayload.commit.author.email);
+      formData.append('commit[branchName]', pushPayload.commit.branchName);
+      formData.append('files[some-file.yaml]', filesMock[0].stream);
+
+      const result = await apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock);
+
+      expect(fetch).toHaveBeenCalledWith(
+        `${testDomain}/api/orgs/${testOrg}/projects/${testProject}/pushes`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${testToken}`,
+          },
+        })
+      );
+
+      expect(
+        JSON.stringify(passedFormData).replace(new RegExp(passedFormData.getBoundary(), 'g'), '')
+      ).toEqual(JSON.stringify(formData).replace(new RegExp(formData.getBoundary(), 'g'), ''));
+      expect(result).toEqual(responseMock);
+    });
+
+    it('should throw parsed error if response is not ok', async () => {
+      mockFetchResponse({
+        ok: false,
+        json: jest.fn().mockResolvedValue({
+          type: 'about:blank',
+          title: 'Cannot push to remote',
+          status: 403,
+          detail: 'Forbidden',
+          object: 'problem',
+        }),
+      });
+
+      await expect(
+        apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock)
+      ).rejects.toThrow(new Error('Failed to push: Cannot push to remote'));
+    });
+
+    it('should throw statusText error if response is not ok', async () => {
+      mockFetchResponse({
+        ok: false,
+        statusText: 'Not found',
+        json: jest.fn().mockResolvedValue({
+          unknownField: 'unknown-error',
+        }),
+      });
+
+      await expect(
+        apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock)
+      ).rejects.toThrow(new Error('Failed to push: Not found'));
+    });
+  });
+});

package/src/cms/api/__tests__/domains.test.ts

@@ -0,0 +1,15 @@
+import { getDomain } from '../domains';
+
+describe('getDomain()', () => {
+  it('should return the domain from environment variable', () => {
+    process.env.REDOCLY_DOMAIN = 'test-domain';
+
+    expect(getDomain()).toBe('test-domain');
+  });
+
+  it('should return the default domain if no domain provided', () => {
+    process.env.REDOCLY_DOMAIN = '';
+
+    expect(getDomain()).toBe('https://app.cloud.redocly.com');
+  });
+});

package/src/cms/api/api-client.ts

@@ -0,0 +1,199 @@
+import fetchWithTimeout from '../../utils/fetch-with-timeout';
+import fetch from 'node-fetch';
+import * as FormData from 'form-data';
+
+import type { Response } from 'node-fetch';
+import type { ReadStream } from 'fs';
+import type {
+  ListRemotesResponse,
+  ProjectSourceResponse,
+  PushResponse,
+  UpsertRemoteResponse,
+} from './types';
+
+class RemotesApiClient {
+  constructor(private readonly domain: string, private readonly apiKey: string) {}
+
+  private async getParsedResponse<T>(response: Response): Promise<T> {
+    const responseBody = await response.json();
+
+    if (response.ok) {
+      return responseBody as T;
+    }
+
+    throw new Error(responseBody.title || response.statusText);
+  }
+
+  async getDefaultBranch(organizationId: string, projectId: string) {
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/source`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    try {
+      const source = await this.getParsedResponse<ProjectSourceResponse>(response);
+
+      return source.branchName;
+    } catch (err) {
+      throw new Error(`Failed to fetch default branch: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async upsert(
+    organizationId: string,
+    projectId: string,
+    remote: {
+      mountPath: string;
+      mountBranchName: string;
+    }
+  ): Promise<UpsertRemoteResponse> {
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          mountPath: remote.mountPath,
+          mountBranchName: remote.mountBranchName,
+          type: 'CICD',
+          autoMerge: true,
+        }),
+      }
+    );
+
+    try {
+      return await this.getParsedResponse<UpsertRemoteResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to upsert remote: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async push(
+    organizationId: string,
+    projectId: string,
+    payload: PushPayload,
+    files: { path: string; stream: ReadStream | Buffer }[]
+  ): Promise<PushResponse> {
+    const formData = new FormData();
+
+    formData.append('remoteId', payload.remoteId);
+    formData.append('commit[message]', payload.commit.message);
+    formData.append('commit[author][name]', payload.commit.author.name);
+    formData.append('commit[author][email]', payload.commit.author.email);
+    formData.append('commit[branchName]', payload.commit.branchName);
+    payload.commit.url && formData.append('commit[url]', payload.commit.url);
+    payload.commit.namespace && formData.append('commit[namespaceId]', payload.commit.namespace);
+    payload.commit.sha && formData.append('commit[sha]', payload.commit.sha);
+    payload.commit.repository && formData.append('commit[repositoryId]', payload.commit.repository);
+    payload.commit.createdAt && formData.append('commit[createdAt]', payload.commit.createdAt);
+
+    for (const file of files) {
+      formData.append(`files[${file.path}]`, file.stream);
+    }
+
+    payload.isMainBranch && formData.append('isMainBranch', 'true');
+
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: formData,
+      }
+    );
+
+    try {
+      return await this.getParsedResponse<PushResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to push: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async getRemotesList(organizationId: string, projectId: string, mountPath: string) {
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes?filter=mountPath:/${mountPath}/`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    try {
+      return await this.getParsedResponse<ListRemotesResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to get remote list: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async getPush({
+    organizationId,
+    projectId,
+    pushId,
+  }: {
+    organizationId: string;
+    projectId: string;
+    pushId: string;
+  }) {
+    const response = await fetchWithTimeout(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes/${pushId}`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    if (!response) {
+      throw new Error(`Failed to get push status: Time is up`);
+    }
+
+    try {
+      return await this.getParsedResponse<PushResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to get push status: ${err.message || 'Unknown error'}`);
+    }
+  }
+}
+
+export class ReuniteApiClient {
+  remotes: RemotesApiClient;
+
+  constructor(public domain: string, private readonly apiKey: string) {
+    this.remotes = new RemotesApiClient(this.domain, this.apiKey);
+  }
+}
+
+export type PushPayload = {
+  remoteId: string;
+  commit: {
+    message: string;
+    branchName: string;
+    sha?: string;
+    url?: string;
+    createdAt?: string;
+    namespace?: string;
+    repository?: string;
+    author: {
+      name: string;
+      email: string;
+      image?: string;
+    };
+  };
+  isMainBranch?: boolean;
+};