@redocly/cli 1.6.0 → 1.8.0

package/lib/wrapper.js

@@ -11,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandWrapper = void 0;
 const openapi_core_1 = require("@redocly/openapi-core");
-const update_version_notifier_1 = require("./update-version-notifier");
-const utils_1 = require("./utils");
+const update_version_notifier_1 = require("./utils/update-version-notifier");
+const miscellaneous_1 = require("./utils/miscellaneous");
 const lint_1 = require("./commands/lint");
 function commandWrapper(commandHandler) {
     return (argv) => __awaiter(this, void 0, void 0, function* () {
@@ -21,9 +21,9 @@ function commandWrapper(commandHandler) {
         let telemetry;
         try {
             if (argv.config && !(0, openapi_core_1.doesYamlFileExist)(argv.config)) {
-                (0, utils_1.exitWithError)('Please, provide valid path to the configuration file');
+                (0, miscellaneous_1.exitWithError)('Please, provide valid path to the configuration file');
             }
-            const config = (yield (0, utils_1.loadConfigAndHandleErrors)({
+            const config = (yield (0, miscellaneous_1.loadConfigAndHandleErrors)({
                 configPath: argv.config,
                 customExtends: argv.extends,
                 region: argv.region,
@@ -41,7 +41,7 @@ function commandWrapper(commandHandler) {
         }
         finally {
             if (process.env.REDOCLY_TELEMETRY !== 'off' && telemetry !== 'off') {
-                yield (0, utils_1.sendTelemetry)(argv, code, hasConfig);
+                yield (0, miscellaneous_1.sendTelemetry)(argv, code, hasConfig);
             }
             process.once('beforeExit', () => {
                 process.exit(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/cli",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "",
   "license": "MIT",
   "bin": {
@@ -36,10 +36,12 @@
     "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/openapi-core": "1.6.0",
+    "@redocly/openapi-core": "1.8.0",
+    "abort-controller": "^3.0.0",
     "chokidar": "^3.5.1",
     "colorette": "^1.2.0",
     "core-js": "^3.32.1",
+    "form-data": "^4.0.0",
     "get-port-please": "^3.0.1",
     "glob": "^7.1.6",
     "handlebars": "^4.7.6",
@@ -59,7 +61,7 @@
     "@types/react": "^17.0.0 || ^18.2.21",
     "@types/react-dom": "^17.0.0 || ^18.2.7",
     "@types/semver": "^7.5.0",
-    "@types/yargs": "17.0.5",
+    "@types/yargs": "17.0.32",
     "typescript": "^5.2.2"
   }
 }

package/src/__tests__/commands/build-docs.test.ts

@@ -3,11 +3,11 @@ import { renderToString } from 'react-dom/server';
 import { handlerBuildCommand } from '../../commands/build-docs';
 import { BuildDocsArgv } from '../../commands/build-docs/types';
 import { getPageHTML } from '../../commands/build-docs/utils';
-import { getFallbackApisOrExit } from '../../utils';
+import { getFallbackApisOrExit } from '../../utils/miscellaneous';
 
 jest.mock('redoc');
 jest.mock('fs');
-jest.mock('../../utils');
+jest.mock('../../utils/miscellaneous');
 
 const config = {
   output: '',

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

@@ -1,13 +1,13 @@
 import { lint, bundle, getTotals, getMergedConfig } from '@redocly/openapi-core';
 
 import { BundleOptions, handleBundle } from '../../commands/bundle';
-import { handleError } from '../../utils';
+import { handleError } from '../../utils/miscellaneous';
 import { commandWrapper } from '../../wrapper';
 import SpyInstance = jest.SpyInstance;
 import { Arguments } from 'yargs';
 
 jest.mock('@redocly/openapi-core');
-jest.mock('../../utils');
+jest.mock('../../utils/miscellaneous');
 
 (getMergedConfig as jest.Mock).mockImplementation((config) => config);
 

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

@@ -1,11 +1,11 @@
 import { handleJoin } from '../../commands/join';
-import { exitWithError, writeToFileByExtension, writeYaml } from '../../utils';
+import { exitWithError, writeToFileByExtension, writeYaml } from '../../utils/miscellaneous';
 import { yellow } from 'colorette';
 import { detectSpec } from '@redocly/openapi-core';
 import { loadConfig } from '../../__mocks__/@redocly/openapi-core';
 import { ConfigFixture } from '../fixtures/config';
 
-jest.mock('../../utils');
+jest.mock('../../utils/miscellaneous');
 
 jest.mock('colorette');
 

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

@@ -14,7 +14,7 @@ import {
   exitWithError,
   loadConfigAndHandleErrors,
   checkIfRulesetExist,
-} from '../../utils';
+} from '../../utils/miscellaneous';
 import { ConfigFixture } from '../fixtures/config';
 import { performance } from 'perf_hooks';
 import { commandWrapper } from '../../wrapper';
@@ -22,10 +22,10 @@ import { Arguments } from 'yargs';
 import { blue } from 'colorette';
 
 jest.mock('@redocly/openapi-core');
-jest.mock('../../utils');
+jest.mock('../../utils/miscellaneous');
 jest.mock('perf_hooks');
 
-jest.mock('../../update-version-notifier', () => ({
+jest.mock('../../utils/update-version-notifier', () => ({
   version: '1.0.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');
@@ -295,6 +292,24 @@ describe('langToExt', () => {
     ['javascript', '.js'],
     ['js', '.js'],
     ['python', '.py'],
+    ['c', '.c'],
+    ['c++', '.cpp'],
+    ['coffeescript', '.litcoffee'],
+    ['dart', '.dart'],
+    ['elixir', '.ex'],
+    ['go', '.go'],
+    ['groovy', '.groovy'],
+    ['java', '.java'],
+    ['kotlin', '.kt'],
+    ['objective-c', '.m'],
+    ['perl', '.pl'],
+    ['powershell', '.ps1'],
+    ['ruby', '.rb'],
+    ['rust', '.rs'],
+    ['scala', '.sc'],
+    ['swift', '.swift'],
+    ['typescript', '.ts'],
+    ['tsx', '.tsx'],
   ])('should infer file extension from lang - %s', (lang, expected) => {
     expect(langToExt(lang)).toBe(expected);
   });

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');
+  });
+});