@redocly/cli 1.11.0 → 1.12.1

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

@@ -29,8 +29,8 @@ describe('handlePush()', () => {
 
   beforeEach(() => {
     remotes.getDefaultBranch.mockResolvedValueOnce('test-default-branch');
-    remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id' });
-    remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch' });
+    remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id', mountPath: 'test-mount-path' });
+    remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch', id: 'test-id' });
 
     jest.spyOn(fs, 'createReadStream').mockReturnValue('stream' as any);
 
@@ -118,6 +118,44 @@ describe('handlePush()', () => {
     );
   });
 
+  it('should return push id', async () => {
+    const mockConfig = { apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    fsStatSyncSpy.mockReturnValueOnce({
+      isDirectory() {
+        return false;
+      },
+    } as any);
+
+    pathResolveSpy.mockImplementationOnce((p) => p);
+    pathRelativeSpy.mockImplementationOnce((_, p) => p);
+    pathDirnameSpy.mockImplementation((_: string) => '.');
+
+    const result = await handlePush(
+      {
+        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,
+      },
+      mockConfig
+    );
+
+    expect(result).toEqual({ pushId: 'test-id' });
+  });
+
   it('should collect files from directory and preserve file structure', async () => {
     const mockConfig = { apis: {} } as any;
     process.env.REDOCLY_AUTHORIZATION = 'test-api-key';

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

@@ -0,0 +1,62 @@
+import { retryUntilConditionMet } from '../utils';
+
+jest.mock('@redocly/openapi-core', () => ({
+  pause: jest.requireActual('@redocly/openapi-core').pause,
+}));
+
+describe('retryUntilConditionMet()', () => {
+  it('should retry until condition meet and return result', async () => {
+    const operation = jest
+      .fn()
+      .mockResolvedValueOnce({ status: 'pending' })
+      .mockResolvedValueOnce({ status: 'pending' })
+      .mockResolvedValueOnce({ status: 'done' });
+
+    const data = await retryUntilConditionMet({
+      operation,
+      condition: (result: any) => result?.status === 'done',
+      retryIntervalMs: 100,
+      retryTimeoutMs: 1000,
+    });
+
+    expect(data).toEqual({ status: 'done' });
+  });
+
+  it('should throw error if condition not meet for desired timeout', async () => {
+    const operation = jest.fn().mockResolvedValue({ status: 'pending' });
+
+    await expect(
+      retryUntilConditionMet({
+        operation,
+        condition: (result: any) => result?.status === 'done',
+        retryIntervalMs: 100,
+        retryTimeoutMs: 1000,
+      })
+    ).rejects.toThrow('Timeout exceeded');
+  });
+
+  it('should call "onConditionNotMet" and "onRetry" callbacks', async () => {
+    const operation = jest
+      .fn()
+      .mockResolvedValueOnce({ status: 'pending' })
+      .mockResolvedValueOnce({ status: 'pending' })
+      .mockResolvedValueOnce({ status: 'done' });
+
+    const onConditionNotMet = jest.fn();
+    const onRetry = jest.fn();
+
+    const data = await retryUntilConditionMet({
+      operation,
+      condition: (result: any) => result?.status === 'done',
+      retryIntervalMs: 100,
+      retryTimeoutMs: 1000,
+      onConditionNotMet,
+      onRetry,
+    });
+
+    expect(data).toEqual({ status: 'done' });
+
+    expect(onConditionNotMet).toHaveBeenCalledTimes(2);
+    expect(onRetry).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -1,15 +1,20 @@
 import * as colors from 'colorette';
-import { Config } from '@redocly/openapi-core';
+import type { Config, OutputFormat } from '@redocly/openapi-core';
+
 import { exitWithError, printExecutionTime } from '../../utils/miscellaneous';
 import { Spinner } from '../../utils/spinner';
 import { DeploymentError } from '../utils';
-import { yellow } from 'colorette';
 import { ReuniteApiClient, getApiKeys, getDomain } from '../api';
 import { capitalize } from '../../utils/js-utils';
+import type {
+  DeploymentStatus,
+  DeploymentStatusResponse,
+  PushResponse,
+  ScorecardItem,
+} from '../api/types';
+import { retryUntilConditionMet } from './utils';
 
-import type { DeploymentStatus, PushResponse, ScorecardItem } from '../api/types';
-
-const INTERVAL = 5000;
+const RETRY_INTERVAL_MS = 5000; // 5 sec
 
 export type PushStatusOptions = {
   organization: string;
@@ -17,12 +22,25 @@ export type PushStatusOptions = {
   pushId: string;
   domain?: string;
   config?: string;
-  format?: 'stylish' | 'json';
+  format?: Extract<OutputFormat, 'stylish'>;
   wait?: boolean;
-  'max-execution-time': number;
+  'max-execution-time'?: number; // in seconds
+  'retry-interval'?: number; // in seconds
+  'start-time'?: number; // in milliseconds
+  'continue-on-deploy-failures'?: boolean;
+  onRetry?: (lasSummary: PushStatusSummary) => void;
 };
 
-export async function handlePushStatus(argv: PushStatusOptions, config: Config) {
+export interface PushStatusSummary {
+  preview: DeploymentStatusResponse;
+  production: DeploymentStatusResponse | null;
+  commit: PushResponse['commit'];
+}
+
+export async function handlePushStatus(
+  argv: PushStatusOptions,
+  config: Config
+): Promise<PushStatusSummary | undefined> {
   const startedAt = performance.now();
   const spinner = new Spinner();
 
@@ -31,123 +49,198 @@ export async function handlePushStatus(argv: PushStatusOptions, config: Config)
   const orgId = organization || config.organization;
 
   if (!orgId) {
-    return exitWithError(
+    exitWithError(
       `No organization provided, please use --organization option or specify the 'organization' field in the config file.`
     );
+    return;
   }
 
   const domain = argv.domain || getDomain();
-
-  if (!domain) {
-    return exitWithError(
-      `No domain provided, please use --domain option or environment variable REDOCLY_DOMAIN.`
-    );
-  }
-
-  const maxExecutionTime = argv['max-execution-time'] || 600;
+  const maxExecutionTime = argv['max-execution-time'] || 1200; // 20 min
+  const retryIntervalMs = argv['retry-interval']
+    ? argv['retry-interval'] * 1000
+    : RETRY_INTERVAL_MS;
+  const startTime = argv['start-time'] || Date.now();
+  const retryTimeoutMs = maxExecutionTime * 1000;
+  const continueOnDeployFailures = argv['continue-on-deploy-failures'] || false;
 
   try {
     const apiKey = getApiKeys(domain);
     const client = new ReuniteApiClient(domain, apiKey);
 
-    if (wait) {
-      const push = await waitForDeployment(client, 'preview');
+    let pushResponse: PushResponse;
 
-      if (push.isMainBranch && push.status.preview.deploy.status === 'success') {
-        await waitForDeployment(client, 'production');
-      }
+    pushResponse = await retryUntilConditionMet({
+      operation: () =>
+        client.remotes.getPush({
+          organizationId: orgId,
+          projectId,
+          pushId,
+        }),
+      condition: wait
+        ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
+          (result) => !['pending', 'running'].includes(result.status['preview'].deploy.status)
+        : null,
+      onConditionNotMet: (lastResult) => {
+        displayDeploymentAndBuildStatus({
+          status: lastResult.status['preview'].deploy.status,
+          url: lastResult.status['preview'].deploy.url,
+          spinner,
+          buildType: 'preview',
+          continueOnDeployFailures,
+          wait,
+        });
+      },
+      onRetry: (lastResult) => {
+        if (argv.onRetry) {
+          argv.onRetry({
+            preview: lastResult.status.preview,
+            production: lastResult.isMainBranch ? lastResult.status.production : null,
+            commit: lastResult.commit,
+          });
+        }
+      },
+      startTime,
+      retryTimeoutMs,
+      retryIntervalMs,
+    });
 
-      printPushStatusInfo();
-      return;
-    }
+    printPushStatus({
+      buildType: 'preview',
+      spinner,
+      wait,
+      push: pushResponse,
+      continueOnDeployFailures,
+    });
+    printScorecard(pushResponse.status.preview.scorecard);
 
-    const pushPreview = await getAndPrintPushStatus(client, 'preview');
-    printScorecard(pushPreview.status.preview.scorecard);
+    const shouldWaitForProdDeployment =
+      pushResponse.isMainBranch &&
+      (wait ? pushResponse.status.preview.deploy.status === 'success' : true);
 
-    if (pushPreview.isMainBranch) {
-      await getAndPrintPushStatus(client, 'production');
-      printScorecard(pushPreview.status.production.scorecard);
+    if (shouldWaitForProdDeployment) {
+      pushResponse = await retryUntilConditionMet({
+        operation: () =>
+          client.remotes.getPush({
+            organizationId: orgId,
+            projectId,
+            pushId,
+          }),
+        condition: wait
+          ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
+            (result) => !['pending', 'running'].includes(result.status['production'].deploy.status)
+          : null,
+        onConditionNotMet: (lastResult) => {
+          displayDeploymentAndBuildStatus({
+            status: lastResult.status['production'].deploy.status,
+            url: lastResult.status['production'].deploy.url,
+            spinner,
+            buildType: 'production',
+            continueOnDeployFailures,
+            wait,
+          });
+        },
+        onRetry: (lastResult) => {
+          if (argv.onRetry) {
+            argv.onRetry({
+              preview: lastResult.status.preview,
+              production: lastResult.isMainBranch ? lastResult.status.production : null,
+              commit: lastResult.commit,
+            });
+          }
+        },
+        startTime,
+        retryTimeoutMs,
+        retryIntervalMs,
+      });
+    }
+
+    if (pushResponse.isMainBranch) {
+      printPushStatus({
+        buildType: 'production',
+        spinner,
+        wait,
+        push: pushResponse,
+        continueOnDeployFailures,
+      });
+      printScorecard(pushResponse.status.production.scorecard);
     }
+    printPushStatusInfo({ orgId, projectId, pushId, startedAt });
 
-    printPushStatusInfo();
+    const summary: PushStatusSummary = {
+      preview: pushResponse.status.preview,
+      production: pushResponse.isMainBranch ? pushResponse.status.production : null,
+      commit: pushResponse.commit,
+    };
+
+    return summary;
   } 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;
+  } finally {
+    spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
   }
+}
 
-  function printPushStatusInfo() {
-    process.stderr.write(
-      `\nProcessed push-status for ${colors.yellow(orgId!)}, ${colors.yellow(
-        projectId
-      )} and pushID ${colors.yellow(pushId)}.\n`
-    );
-    printExecutionTime('push-status', startedAt, 'Finished');
-  }
-
-  async function waitForDeployment(
-    client: ReuniteApiClient,
-    buildType: 'preview' | 'production'
-  ): Promise<PushResponse> {
-    return new Promise((resolve, reject) => {
-      if (performance.now() - startedAt > maxExecutionTime * 1000) {
-        spinner.stop();
-        reject(new Error(`Time limit exceeded.`));
-      }
-
-      getAndPrintPushStatus(client, buildType)
-        .then((push) => {
-          if (!['pending', 'running'].includes(push.status[buildType].deploy.status)) {
-            printScorecard(push.status[buildType].scorecard);
-            resolve(push);
-            return;
-          }
+function printPushStatusInfo({
+  orgId,
+  projectId,
+  pushId,
+  startedAt,
+}: {
+  orgId: string;
+  projectId: string;
+  pushId: string;
+  startedAt: number;
+}) {
+  process.stderr.write(
+    `\nProcessed push-status for ${colors.yellow(orgId!)}, ${colors.yellow(
+      projectId
+    )} and pushID ${colors.yellow(pushId)}.\n`
+  );
+  printExecutionTime('push-status', startedAt, 'Finished');
+}
 
-          setTimeout(async () => {
-            try {
-              const pushResponse = await waitForDeployment(client, buildType);
-              resolve(pushResponse);
-            } catch (e) {
-              reject(e);
-            }
-          }, INTERVAL);
-        })
-        .catch(reject);
-    });
+function printPushStatus({
+  buildType,
+  spinner,
+  push,
+  continueOnDeployFailures,
+}: {
+  buildType: 'preview' | 'production';
+  spinner: Spinner;
+  wait?: boolean;
+  push?: PushResponse | null;
+  continueOnDeployFailures: boolean;
+}) {
+  if (!push) {
+    return;
   }
-
-  async function getAndPrintPushStatus(
-    client: ReuniteApiClient,
-    buildType: 'preview' | 'production'
-  ) {
-    const push = await client.remotes.getPush({
-      organizationId: orgId!,
-      projectId,
-      pushId,
+  if (push.isOutdated || !push.hasChanges) {
+    process.stderr.write(
+      colors.yellow(
+        `Files not added to your project. Reason: ${push.isOutdated ? 'outdated' : 'no changes'}.\n`
+      )
+    );
+  } else {
+    displayDeploymentAndBuildStatus({
+      status: push.status[buildType].deploy.status,
+      url: push.status[buildType].deploy.url,
+      buildType,
+      spinner,
+      continueOnDeployFailures,
     });
-
-    if (push.isOutdated || !push.hasChanges) {
-      process.stderr.write(
-        yellow(`Files not uploaded. Reason: ${push.isOutdated ? 'outdated' : 'no changes'}.\n`)
-      );
-    } else {
-      displayDeploymentAndBuildStatus({
-        status: push.status[buildType].deploy.status,
-        previewUrl: push.status[buildType].deploy.url,
-        buildType,
-        spinner,
-        wait,
-      });
-    }
-
-    return push;
   }
 }
 
-function printScorecard(scorecard: ScorecardItem[]) {
-  if (!scorecard.length) {
+function printScorecard(scorecard?: ScorecardItem[]) {
+  if (!scorecard || scorecard.length === 0) {
     return;
   }
   process.stdout.write(`\n${colors.magenta('Scorecard')}:`);
@@ -163,42 +256,71 @@ function printScorecard(scorecard: ScorecardItem[]) {
 
 function displayDeploymentAndBuildStatus({
   status,
-  previewUrl,
+  url,
   spinner,
   buildType,
+  continueOnDeployFailures,
   wait,
 }: {
   status: DeploymentStatus;
-  previewUrl: string | null;
+  url: string | null;
   spinner: Spinner;
   buildType: 'preview' | 'production';
+  continueOnDeployFailures: boolean;
   wait?: boolean;
 }) {
+  const message = getMessage({ status, url, buildType, wait });
+
+  if (status === 'failed' && !continueOnDeployFailures) {
+    spinner.stop();
+    throw new DeploymentError(message);
+  }
+
+  if (wait && (status === 'pending' || status === 'running')) {
+    return spinner.start(message);
+  }
+
+  spinner.stop();
+  return process.stdout.write(message);
+}
+
+function getMessage({
+  status,
+  url,
+  buildType,
+  wait,
+}: {
+  status: DeploymentStatus;
+  url: string | null;
+  buildType: 'preview' | 'production';
+  wait?: boolean;
+}): string {
   switch (status) {
+    case 'skipped':
+      return `${colors.yellow(`Skipped ${buildType}`)}\n`;
+
+    case 'pending': {
+      const message = `${colors.yellow(`Pending ${buildType}`)}`;
+      return wait ? message : `Status: ${message}\n`;
+    }
+    case 'running': {
+      const message = `${colors.yellow(`Running ${buildType}`)}`;
+      return wait ? message : `Status: ${message}\n`;
+    }
     case 'success':
-      spinner.stop();
-      return process.stdout.write(
-        `${colors.green(`🚀 ${capitalize(buildType)} deploy success.`)}\n${colors.magenta(
-          `${capitalize(buildType)} URL`
-        )}: ${colors.cyan(previewUrl!)}\n`
-      );
+      return `${colors.green(`🚀 ${capitalize(buildType)} deploy success.`)}\n${colors.magenta(
+        `${capitalize(buildType)} URL`
+      )}: ${colors.cyan(url || 'No URL yet.')}\n`;
+
     case 'failed':
-      spinner.stop();
-      throw new DeploymentError(
-        `${colors.red(`❌ ${capitalize(buildType)} deploy fail.`)}\n${colors.magenta(
-          `${capitalize(buildType)} URL`
-        )}: ${colors.cyan(previewUrl!)}`
-      );
-    case 'pending':
-      return wait
-        ? spinner.start(`${colors.yellow(`Pending ${buildType}`)}`)
-        : process.stdout.write(`Status: ${colors.yellow(`Pending ${buildType}`)}\n`);
-    case 'skipped':
-      spinner.stop();
-      return process.stdout.write(`${colors.yellow(`Skipped ${buildType}`)}\n`);
-    case 'running':
-      return wait
-        ? spinner.start(`${colors.yellow(`Running ${buildType}`)}`)
-        : process.stdout.write(`Status: ${colors.yellow(`Running ${buildType}`)}\n`);
+      return `${colors.red(`❌ ${capitalize(buildType)} deploy fail.`)}\n${colors.magenta(
+        `${capitalize(buildType)} URL`
+      )}: ${colors.cyan(url || 'No URL yet.')}`;
+
+    default: {
+      const message = `${colors.yellow(`No status yet for ${buildType} deploy`)}`;
+
+      return wait ? message : `Status: ${message}\n`;
+    }
   }
 }

package/src/cms/commands/push.ts

@@ -1,9 +1,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { Config, slash } from '@redocly/openapi-core';
-import { exitWithError, HandledError, printExecutionTime } from '../../utils/miscellaneous';
+import { slash } from '@redocly/openapi-core';
 import { green, yellow } from 'colorette';
 import pluralize = require('pluralize');
+
+import type { OutputFormat, Config } from '@redocly/openapi-core';
+
+import { exitWithError, HandledError, printExecutionTime } from '../../utils/miscellaneous';
 import { handlePushStatus } from './push-status';
 import { ReuniteApiClient, getDomain, getApiKeys } from '../api';
 
@@ -29,13 +32,20 @@ export type PushOptions = {
   config?: string;
   'wait-for-deployment'?: boolean;
   'max-execution-time': number;
+  'continue-on-deploy-failures'?: boolean;
   verbose?: boolean;
+  format?: Extract<OutputFormat, 'stylish'>;
 };
 
 type FileToUpload = { name: string; path: string };
 
-export async function handlePush(argv: PushOptions, config: Config) {
-  const startedAt = performance.now();
+export async function handlePush(
+  argv: PushOptions,
+  config: Config
+): Promise<{ pushId: string } | void> {
+  const startedAt = performance.now(); // for printing execution time
+  const startTime = Date.now(); // for push-status command
+
   const { organization, project: projectId, 'mount-path': mountPath, verbose } = argv;
 
   const orgId = organization || config.organization;
@@ -111,8 +121,8 @@ export async function handlePush(argv: PushOptions, config: Config) {
     filesToUpload.forEach((f) => {
       process.stderr.write(green(`✓ ${f.name}\n`));
     });
-    process.stdout.write('\n');
 
+    process.stdout.write('\n');
     process.stdout.write(`Push ID: ${id}\n`);
 
     if (waitForDeployment) {
@@ -126,6 +136,8 @@ export async function handlePush(argv: PushOptions, config: Config) {
           wait: true,
           domain,
           'max-execution-time': maxExecutionTime,
+          'start-time': startTime,
+          'continue-on-deploy-failures': argv['continue-on-deploy-failures'],
         },
         config
       );
@@ -139,6 +151,10 @@ export async function handlePush(argv: PushOptions, config: Config) {
           filesToUpload.length
         )} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`
       );
+
+    return {
+      pushId: id,
+    };
   } catch (err) {
     const message =
       err instanceof HandledError ? '' : `✗ File upload failed. Reason: ${err.message}`;

package/src/cms/commands/utils.ts

@@ -0,0 +1,52 @@
+import { pause } from '@redocly/openapi-core';
+
+/**
+ * This function retries an operation until a condition is met or a timeout is exceeded.
+ * If the condition is not met within the timeout, an error is thrown.
+ * @operation The operation to retry.
+ * @condition The condition to check after each operation result. Return false to continue retrying. Return true to stop retrying.
+ *            If not provided, the first result will be returned.
+ * @param onConditionNotMet Will be called with the last result right after checking condition and before timeout and retrying.
+ * @param onRetry Will be called right before retrying operation with the last result before retrying.
+ * @param startTime The start time of the operation. Default is the current time.
+ * @param retryTimeoutMs The maximum time to retry the operation. Default is 10 minutes.
+ * @param retryIntervalMs The interval between retries. Default is 5 seconds.
+ */
+export async function retryUntilConditionMet<T>({
+  operation,
+  condition,
+  onConditionNotMet,
+  onRetry,
+  startTime = Date.now(),
+  retryTimeoutMs = 600000, // 10 min
+  retryIntervalMs = 5000, // 5 sec
+}: {
+  operation: () => Promise<T>;
+  condition?: ((result: T) => boolean) | null;
+  onConditionNotMet?: (lastResult: T) => void;
+  onRetry?: (lastResult: T) => void | Promise<void>;
+  startTime?: number;
+  retryTimeoutMs?: number;
+  retryIntervalMs?: number;
+}): Promise<T> {
+  async function attempt(): Promise<T> {
+    const result = await operation();
+
+    if (!condition) {
+      return result;
+    }
+
+    if (condition(result)) {
+      return result;
+    } else if (Date.now() - startTime > retryTimeoutMs) {
+      throw new Error('Timeout exceeded');
+    } else {
+      onConditionNotMet?.(result);
+      await pause(retryIntervalMs);
+      await onRetry?.(result);
+      return attempt();
+    }
+  }
+
+  return attempt();
+}