@redocly/cli 1.22.1 → 1.23.0

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

@@ -1,7 +1,8 @@
-import fetch from 'node-fetch';
 import * as FormData from 'form-data';
-import { getProxyAgent } from '@redocly/openapi-core';
-import fetchWithTimeout from '../../utils/fetch-with-timeout';
+import fetchWithTimeout, {
+  type FetchWithTimeoutOptions,
+  DEFAULT_FETCH_TIMEOUT,
+} from '../../utils/fetch-with-timeout';
 
 import type { Response } from 'node-fetch';
 import type { ReadStream } from 'fs';
@@ -12,41 +13,76 @@ import type {
   UpsertRemoteResponse,
 } from './types';
 
-class RemotesApiClient {
-  constructor(private readonly domain: string, private readonly apiKey: string) {}
+export class ReuniteApiError extends Error {
+  constructor(message: string, public status: number) {
+    super(message);
+  }
+}
 
-  private async getParsedResponse<T>(response: Response): Promise<T> {
+class ReuniteBaseApiClient {
+  constructor(protected version: string, protected command: string) {}
+
+  protected 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);
+    throw new ReuniteApiError(
+      `${responseBody.title || response.statusText || 'Unknown error'}.`,
+      response.status
+    );
   }
 
-  async getDefaultBranch(organizationId: string, projectId: string) {
-    const response = await fetchWithTimeout(
-      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/source`,
-      {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.apiKey}`,
-        },
-      }
-    );
+  protected request(url: string, options: FetchWithTimeoutOptions) {
+    const headers = {
+      ...options.headers,
+      'user-agent': `redocly-cli/${this.version.trim()} ${this.command}`,
+    };
 
-    if (!response) {
-      throw new Error(`Failed to get default branch.`);
-    }
+    return fetchWithTimeout(url, {
+      ...options,
+      headers,
+    });
+  }
+}
 
+class RemotesApiClient extends ReuniteBaseApiClient {
+  constructor(
+    private readonly domain: string,
+    private readonly apiKey: string,
+    version: string,
+    command: string
+  ) {
+    super(version, command);
+  }
+
+  async getDefaultBranch(organizationId: string, projectId: string) {
     try {
+      const response = await this.request(
+        `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/source`,
+        {
+          timeout: DEFAULT_FETCH_TIMEOUT,
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+        }
+      );
+
       const source = await this.getParsedResponse<ProjectSourceResponse>(response);
 
       return source.branchName;
     } catch (err) {
-      throw new Error(`Failed to fetch default branch: ${err.message || 'Unknown error'}`);
+      const message = `Failed to fetch default branch. ${err.message}`;
+
+      if (err instanceof ReuniteApiError) {
+        throw new ReuniteApiError(message, err.status);
+      }
+
+      throw new Error(message);
     }
   }
 
@@ -58,31 +94,34 @@ class RemotesApiClient {
       mountBranchName: string;
     }
   ): Promise<UpsertRemoteResponse> {
-    const response = await fetchWithTimeout(
-      `${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,
-        }),
-      }
-    );
-
-    if (!response) {
-      throw new Error(`Failed to upsert.`);
-    }
-
     try {
+      const response = await this.request(
+        `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes`,
+        {
+          timeout: DEFAULT_FETCH_TIMEOUT,
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+          body: JSON.stringify({
+            mountPath: remote.mountPath,
+            mountBranchName: remote.mountBranchName,
+            type: 'CICD',
+            autoMerge: true,
+          }),
+        }
+      );
+
       return await this.getParsedResponse<UpsertRemoteResponse>(response);
     } catch (err) {
-      throw new Error(`Failed to upsert remote: ${err.message || 'Unknown error'}`);
+      const message = `Failed to upsert remote. ${err.message}`;
+
+      if (err instanceof ReuniteApiError) {
+        throw new ReuniteApiError(message, err.status);
+      }
+
+      throw new Error(message);
     }
   }
 
@@ -110,46 +149,61 @@ class RemotesApiClient {
     }
 
     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,
-        agent: getProxyAgent(),
-      }
-    );
-
     try {
+      const response = await this.request(
+        `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes`,
+        {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+          body: formData,
+        }
+      );
+
       return await this.getParsedResponse<PushResponse>(response);
     } catch (err) {
-      throw new Error(`Failed to push: ${err.message || 'Unknown error'}`);
-    }
-  }
+      const message = `Failed to push. ${err.message}`;
 
-  async getRemotesList(organizationId: string, projectId: string, mountPath: string) {
-    const response = await fetchWithTimeout(
-      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes?filter=mountPath:/${mountPath}/`,
-      {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.apiKey}`,
-        },
+      if (err instanceof ReuniteApiError) {
+        throw new ReuniteApiError(message, err.status);
       }
-    );
 
-    if (!response) {
-      throw new Error(`Failed to get remotes list.`);
+      throw new Error(message);
     }
+  }
 
+  async getRemotesList({
+    organizationId,
+    projectId,
+    mountPath,
+  }: {
+    organizationId: string;
+    projectId: string;
+    mountPath: string;
+  }) {
     try {
+      const response = await this.request(
+        `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes?filter=mountPath:/${mountPath}/`,
+        {
+          timeout: DEFAULT_FETCH_TIMEOUT,
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+        }
+      );
+
       return await this.getParsedResponse<ListRemotesResponse>(response);
     } catch (err) {
-      throw new Error(`Failed to get remote list: ${err.message || 'Unknown error'}`);
+      const message = `Failed to get remote list. ${err.message}`;
+
+      if (err instanceof ReuniteApiError) {
+        throw new ReuniteApiError(message, err.status);
+      }
+
+      throw new Error(message);
     }
   }
 
@@ -162,25 +216,28 @@ class RemotesApiClient {
     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.`);
-    }
-
     try {
+      const response = await this.request(
+        `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes/${pushId}`,
+        {
+          timeout: DEFAULT_FETCH_TIMEOUT,
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+        }
+      );
+
       return await this.getParsedResponse<PushResponse>(response);
     } catch (err) {
-      throw new Error(`Failed to get push status: ${err.message || 'Unknown error'}`);
+      const message = `Failed to get push status. ${err.message}`;
+
+      if (err instanceof ReuniteApiError) {
+        throw new ReuniteApiError(message, err.status);
+      }
+
+      throw new Error(message);
     }
   }
 }
@@ -188,8 +245,18 @@ class RemotesApiClient {
 export class ReuniteApiClient {
   remotes: RemotesApiClient;
 
-  constructor(public domain: string, private readonly apiKey: string) {
-    this.remotes = new RemotesApiClient(this.domain, this.apiKey);
+  constructor({
+    domain,
+    apiKey,
+    version,
+    command,
+  }: {
+    domain: string;
+    apiKey: string;
+    version: string;
+    command: 'push' | 'push-status';
+  }) {
+    this.remotes = new RemotesApiClient(domain, apiKey, version, command);
   }
 }
 

package/src/cms/commands/__tests__/push-status.test.ts

@@ -644,7 +644,7 @@ describe('handlePushStatus()', () => {
           version: 'cli-version',
         })
       ).rejects.toThrowErrorMatchingInlineSnapshot(`
-        "✗ Failed to get push status. Reason: Timeout exceeded
+        "✗ Failed to get push status. Reason: Timeout exceeded.
         "
       `);
     });

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

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { handlePush } from '../push';
-import { ReuniteApiClient } from '../../api';
+import { ReuniteApiClient, ReuniteApiError } from '../../api';
 
 const remotes = {
   push: jest.fn(),
@@ -332,6 +332,53 @@ describe('handlePush()', () => {
       version: 'cli-version',
     });
 
-    expect(ReuniteApiClient).toBeCalledWith('test-domain-from-env', 'test-api-key');
+    expect(ReuniteApiClient).toBeCalledWith({
+      domain: 'test-domain-from-env',
+      apiKey: 'test-api-key',
+      version: 'cli-version',
+      command: 'push',
+    });
+  });
+
+  it('should print error message', async () => {
+    const mockConfig = { apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    remotes.push.mockRestore();
+    remotes.push.mockRejectedValueOnce(new ReuniteApiError('Deprecated.', 412));
+
+    fsStatSyncSpy.mockReturnValueOnce({
+      isDirectory() {
+        return false;
+      },
+    } as any);
+
+    pathResolveSpy.mockImplementationOnce((p) => p);
+    pathRelativeSpy.mockImplementationOnce((_, p) => p);
+    pathDirnameSpy.mockImplementation((_: string) => '.');
+
+    expect(
+      handlePush({
+        argv: {
+          domain: 'test-domain',
+          'mount-path': 'test-mount-path',
+          organization: 'test-org',
+          project: 'test-project',
+          branch: 'test-branch',
+          namespace: 'test-namespace',
+          repository: 'test-repository',
+          'commit-sha': 'test-commit-sha',
+          'commit-url': 'test-commit-url',
+          'default-branch': 'test-branch',
+          'created-at': 'test-created-at',
+          author: 'TestAuthor <test-author@mail.com>',
+          message: 'Test message',
+          files: ['test-file'],
+          'max-execution-time': 10,
+        },
+        config: mockConfig,
+        version: 'cli-version',
+      })
+    ).rejects.toThrow('✗ File upload failed. Reason: Deprecated.');
   });
 });

package/src/cms/commands/__tests__/utils.test.ts

@@ -32,7 +32,7 @@ describe('retryUntilConditionMet()', () => {
         retryIntervalMs: 100,
         retryTimeoutMs: 1000,
       })
-    ).rejects.toThrow('Timeout exceeded');
+    ).rejects.toThrow('Timeout exceeded.');
   });
 
   it('should call "onConditionNotMet" and "onRetry" callbacks', async () => {

package/src/cms/commands/push-status.ts

@@ -4,7 +4,7 @@ import { Spinner } from '../../utils/spinner';
 import { DeploymentError } from '../utils';
 import { ReuniteApiClient, getApiKeys, getDomain } from '../api';
 import { capitalize } from '../../utils/js-utils';
-import { retryUntilConditionMet } from './utils';
+import { handleReuniteError, retryUntilConditionMet } from './utils';
 
 import type { OutputFormat } from '@redocly/openapi-core';
 import type { CommandArgs } from '../../wrapper';
@@ -41,7 +41,8 @@ export interface PushStatusSummary {
 export async function handlePushStatus({
   argv,
   config,
-}: CommandArgs<PushStatusOptions>): Promise<PushStatusSummary | undefined> {
+  version,
+}: CommandArgs<PushStatusOptions>): Promise<PushStatusSummary | void> {
   const startedAt = performance.now();
   const spinner = new Spinner();
 
@@ -67,7 +68,7 @@ export async function handlePushStatus({
 
   try {
     const apiKey = getApiKeys(domain);
-    const client = new ReuniteApiClient(domain, apiKey);
+    const client = new ReuniteApiClient({ domain, apiKey, version, command: 'push-status' });
 
     let pushResponse: PushResponse;
 
@@ -178,12 +179,7 @@ export async function handlePushStatus({
   } catch (err) {
     spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
 
-    const message =
-      err instanceof DeploymentError
-        ? err.message
-        : `✗ Failed to get push status. Reason: ${err.message}\n`;
-    exitWithError(message);
-    return;
+    handleReuniteError('✗ Failed to get push status.', err);
   } finally {
     spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
   }

package/src/cms/commands/push.ts

@@ -3,9 +3,10 @@ import * as path from 'path';
 import { slash } from '@redocly/openapi-core';
 import { pluralize } from '@redocly/openapi-core/lib/utils';
 import { green, yellow } from 'colorette';
-import { exitWithError, HandledError, printExecutionTime } from '../../utils/miscellaneous';
+import { exitWithError, printExecutionTime } from '../../utils/miscellaneous';
 import { handlePushStatus } from './push-status';
 import { ReuniteApiClient, getDomain, getApiKeys } from '../api';
+import { handleReuniteError } from './utils';
 
 import type { OutputFormat } from '@redocly/openapi-core';
 import type { CommandArgs } from '../../wrapper';
@@ -52,7 +53,7 @@ export async function handlePush({
   const orgId = organization || config.organization;
 
   if (!argv.message || !argv.author || !argv.branch) {
-    exitWithError('Error: message, author and branch are required for push to the CMS.');
+    exitWithError('Error: message, author and branch are required for push to the Reunite.');
   }
 
   if (!orgId) {
@@ -85,7 +86,7 @@ export async function handlePush({
       return printExecutionTime('push', startedAt, `No files to upload`);
     }
 
-    const client = new ReuniteApiClient(domain, apiKey);
+    const client = new ReuniteApiClient({ domain, apiKey, version, command: 'push' });
     const projectDefaultBranch = await client.remotes.getDefaultBranch(orgId, projectId);
     const remote = await client.remotes.upsert(orgId, projectId, {
       mountBranchName: projectDefaultBranch,
@@ -158,9 +159,7 @@ export async function handlePush({
       pushId: id,
     };
   } catch (err) {
-    const message =
-      err instanceof HandledError ? '' : `✗ File upload failed. Reason: ${err.message}`;
-    exitWithError(message);
+    handleReuniteError('✗ File upload failed.', err);
   }
 }
 

package/src/cms/commands/utils.ts

@@ -1,4 +1,8 @@
 import { pause } from '@redocly/openapi-core';
+import { DeploymentError } from '../utils';
+import { exitWithError } from '../../utils/miscellaneous';
+
+import type { ReuniteApiError } from '../api';
 
 /**
  * This function retries an operation until a condition is met or a timeout is exceeded.
@@ -39,7 +43,7 @@ export async function retryUntilConditionMet<T>({
     if (condition(result)) {
       return result;
     } else if (Date.now() - startTime > retryTimeoutMs) {
-      throw new Error('Timeout exceeded');
+      throw new Error('Timeout exceeded.');
     } else {
       onConditionNotMet?.(result);
       await pause(retryIntervalMs);
@@ -50,3 +54,13 @@ export async function retryUntilConditionMet<T>({
 
   return attempt();
 }
+
+export function handleReuniteError(
+  message: string,
+  error: ReuniteApiError | DeploymentError | Error
+) {
+  const errorMessage =
+    error instanceof DeploymentError ? error.message : `${message} Reason: ${error.message}\n`;
+
+  return exitWithError(errorMessage);
+}

package/src/commands/bundle.ts

@@ -21,7 +21,7 @@ export type BundleOptions = {
   apis?: string[];
   extends?: string[];
   output?: string;
-  ext: OutputExtensions;
+  ext?: OutputExtensions;
   dereferenced?: boolean;
   force?: boolean;
   metafile?: string;
@@ -45,7 +45,7 @@ export async function handleBundle({
 
   checkForDeprecatedOptions(argv, deprecatedOptions);
 
-  for (const { path, alias } of apis) {
+  for (const { path, alias, output } of apis) {
     try {
       const startedAt = performance.now();
       const resolvedConfig = getMergedConfig(config, alias);
@@ -70,19 +70,19 @@ export async function handleBundle({
       });
 
       const fileTotals = getTotals(problems);
-      const { outputFile, ext } = getOutputFileName(path, apis.length, argv.output, argv.ext);
+      const { outputFile, ext } = getOutputFileName(path, output || argv.output, argv.ext);
 
       if (fileTotals.errors === 0 || argv.force) {
-        if (!argv.output) {
-          const output = dumpBundle(
+        if (!outputFile) {
+          const bundled = dumpBundle(
             sortTopLevelKeysForOas(result.parsed),
             argv.ext || 'yaml',
             argv.dereferenced
           );
-          process.stdout.write(output);
+          process.stdout.write(bundled);
         } else {
-          const output = dumpBundle(sortTopLevelKeysForOas(result.parsed), ext, argv.dereferenced);
-          saveBundle(outputFile, output);
+          const bundled = dumpBundle(sortTopLevelKeysForOas(result.parsed), ext, argv.dereferenced);
+          saveBundle(outputFile, bundled);
         }
       }
 
@@ -111,9 +111,9 @@ export async function handleBundle({
       if (fileTotals.errors > 0) {
         if (argv.force) {
           process.stderr.write(
-            `❓ Created a bundle for ${blue(path)} at ${blue(outputFile)} with errors ${green(
-              elapsed
-            )}.\n${yellow('Errors ignored because of --force')}.\n`
+            `❓ Created a bundle for ${blue(path)} at ${blue(
+              outputFile || 'stdout'
+            )} with errors ${green(elapsed)}.\n${yellow('Errors ignored because of --force')}.\n`
           );
         } else {
           process.stderr.write(
@@ -124,7 +124,9 @@ export async function handleBundle({
         }
       } else {
         process.stderr.write(
-          `📦 Created a bundle for ${blue(path)} at ${blue(outputFile)} ${green(elapsed)}.\n`
+          `📦 Created a bundle for ${blue(path)} at ${blue(outputFile || 'stdout')} ${green(
+            elapsed
+          )}.\n`
         );
       }
 

package/src/commands/eject.ts

@@ -5,7 +5,7 @@ import type { VerifyConfigOptions } from '../types';
 
 export type EjectOptions = {
   type: 'component';
-  path: string;
+  path?: string;
   'project-dir'?: string;
   force: boolean;
 } & VerifyConfigOptions;
@@ -20,7 +20,7 @@ export const handleEject = async ({ argv }: CommandArgs<EjectOptions>) => {
       '@redocly/realm',
       'eject',
       `${argv.type}`,
-      `${argv.path}`,
+      `${argv.path ?? ''}`,
       `-d=${argv['project-dir']}`,
       argv.force ? `--force=${argv.force}` : '',
     ],

package/src/commands/preview-project/index.ts

@@ -26,7 +26,7 @@ export const previewProject = async ({ argv }: CommandArgs<PreviewProjectOptions
 
   spawn(
     npxExecutableName,
-    ['-y', packageName, 'develop', `--plan=${plan}`, `--port=${port || 4000}`],
+    ['-y', packageName, 'preview', `--plan=${plan}`, `--port=${port || 4000}`],
     {
       stdio: 'inherit',
       cwd: projectDir,

package/src/index.ts

@@ -817,7 +817,7 @@ yargs
     }
   )
   .command(
-    'eject <type> <path>',
+    'eject <type> [path]',
     'Helper function to eject project elements for customization.',
     (yargs) =>
       yargs
@@ -830,7 +830,6 @@ yargs
         .positional('path', {
           description: 'Filepath to a component or filepath with glob pattern.',
           type: 'string',
-          demandOption: true,
         })
         .options({
           'project-dir': {

package/src/types.ts

@@ -23,6 +23,7 @@ export type Totals = {
 export type Entrypoint = {
   path: string;
   alias?: string;
+  output?: string;
 };
 export const outputExtensions = ['json', 'yaml', 'yml'] as ReadonlyArray<BundleOutputFormat>;
 export type OutputExtensions = 'json' | 'yaml' | 'yml' | undefined;

package/src/utils/__mocks__/miscellaneous.ts

@@ -20,3 +20,4 @@ export const sortTopLevelKeysForOas = jest.fn((document) => document);
 export const getAndValidateFileExtension = jest.fn((fileName: string) => fileName.split('.').pop());
 export const writeToFileByExtension = jest.fn();
 export const checkForDeprecatedOptions = jest.fn();
+export const saveBundle = jest.fn();