@redocly/cli 1.34.3 → 2.0.0-next.0

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

@@ -1,325 +0,0 @@
-import * as colors from 'colorette';
-import { exitWithError, printExecutionTime } from '../../utils/miscellaneous';
-import { Spinner } from '../../utils/spinner';
-import { DeploymentError } from '../utils';
-import { ReuniteApi, getApiKeys, getDomain } from '../api';
-import { capitalize } from '../../utils/js-utils';
-import { handleReuniteError, retryUntilConditionMet } from './utils';
-
-import type { OutputFormat } from '@redocly/openapi-core';
-import type { CommandArgs } from '../../wrapper';
-import type {
-  DeploymentStatus,
-  DeploymentStatusResponse,
-  PushResponse,
-  ScorecardItem,
-} from '../api/types';
-
-const RETRY_INTERVAL_MS = 5000; // 5 sec
-
-export type PushStatusOptions = {
-  organization: string;
-  project: string;
-  pushId: string;
-  domain?: string;
-  config?: string;
-  format?: Extract<OutputFormat, 'stylish'>;
-  wait?: boolean;
-  '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 interface PushStatusSummary {
-  preview: DeploymentStatusResponse;
-  production: DeploymentStatusResponse | null;
-  commit: PushResponse['commit'];
-}
-
-export async function handlePushStatus({
-  argv,
-  config,
-  version,
-}: CommandArgs<PushStatusOptions>): Promise<PushStatusSummary | void> {
-  const startedAt = performance.now();
-  const spinner = new Spinner();
-
-  const { organization, project: projectId, pushId, wait } = argv;
-
-  const orgId = organization || config.organization;
-
-  if (!orgId) {
-    exitWithError(
-      `No organization provided, please use --organization option or specify the 'organization' field in the config file.`
-    );
-    return;
-  }
-
-  const domain = argv.domain || getDomain();
-  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 ReuniteApi({ domain, apiKey, version, command: 'push-status' });
-
-    let pushResponse: PushResponse;
-
-    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,
-    });
-
-    printPushStatus({
-      buildType: 'preview',
-      spinner,
-      wait,
-      push: pushResponse,
-      continueOnDeployFailures,
-    });
-    printScorecard(pushResponse.status.preview.scorecard);
-
-    const shouldWaitForProdDeployment =
-      pushResponse.isMainBranch &&
-      (wait ? pushResponse.status.preview.deploy.status === 'success' : true);
-
-    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 });
-
-    client.reportSunsetWarnings();
-
-    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.
-
-    handleReuniteError('✗ Failed to get push status.', err);
-  } finally {
-    spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
-  }
-}
-
-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');
-}
-
-function printPushStatus({
-  buildType,
-  spinner,
-  push,
-  continueOnDeployFailures,
-}: {
-  buildType: 'preview' | 'production';
-  spinner: Spinner;
-  wait?: boolean;
-  push?: PushResponse | null;
-  continueOnDeployFailures: boolean;
-}) {
-  if (!push) {
-    return;
-  }
-  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,
-    });
-  }
-}
-
-function printScorecard(scorecard?: ScorecardItem[]) {
-  if (!scorecard || scorecard.length === 0) {
-    return;
-  }
-  process.stdout.write(`\n${colors.magenta('Scorecard')}:`);
-  for (const scorecardItem of scorecard) {
-    process.stdout.write(`
-    ${colors.magenta('Name')}: ${scorecardItem.name}
-    ${colors.magenta('Status')}: ${scorecardItem.status}
-    ${colors.magenta('URL')}: ${colors.cyan(scorecardItem.url)}
-    ${colors.magenta('Description')}: ${scorecardItem.description}\n`);
-  }
-  process.stdout.write(`\n`);
-}
-
-function displayDeploymentAndBuildStatus({
-  status,
-  url,
-  spinner,
-  buildType,
-  continueOnDeployFailures,
-  wait,
-}: {
-  status: DeploymentStatus;
-  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':
-      return `${colors.green(`🚀 ${capitalize(buildType)} deploy success.`)}\n${colors.magenta(
-        `${capitalize(buildType)} URL`
-      )}: ${colors.cyan(url || 'No URL yet.')}\n`;
-
-    case 'failed':
-      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/reunite/commands/push.ts

@@ -1,235 +0,0 @@
-import * as fs from 'fs';
-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, printExecutionTime } from '../../utils/miscellaneous';
-import { handlePushStatus } from './push-status';
-import { ReuniteApi, getDomain, getApiKeys } from '../api';
-import { handleReuniteError } from './utils';
-
-import type { OutputFormat } from '@redocly/openapi-core';
-import type { CommandArgs } from '../../wrapper';
-import type { VerifyConfigOptions } from '../../types';
-
-export type PushOptions = {
-  apis?: string[];
-  organization?: string;
-  project: string;
-  'mount-path': string;
-
-  branch: string;
-  author: string;
-  message: string;
-  'commit-sha'?: string;
-  'commit-url'?: string;
-  namespace?: string;
-  repository?: string;
-  'created-at'?: string;
-
-  files: string[];
-
-  'default-branch': string;
-  domain?: string;
-  'wait-for-deployment'?: boolean;
-  'max-execution-time': number;
-  'continue-on-deploy-failures'?: boolean;
-  verbose?: boolean;
-  format?: Extract<OutputFormat, 'stylish'>;
-} & VerifyConfigOptions;
-
-type FileToUpload = { name: string; path: string };
-
-export async function handlePush({
-  argv,
-  config,
-  version,
-}: CommandArgs<PushOptions>): 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;
-
-  if (!argv.message || !argv.author || !argv.branch) {
-    exitWithError('Error: message, author and branch are required for push to the Reunite.');
-  }
-
-  if (!orgId) {
-    return exitWithError(
-      `No organization provided, please use --organization option or specify the 'organization' field in the config file.`
-    );
-  }
-
-  const domain = argv.domain || getDomain();
-
-  if (!domain) {
-    return exitWithError(
-      `No domain provided, please use --domain option or environment variable REDOCLY_AUTHORIZATION.`
-    );
-  }
-
-  try {
-    const {
-      'commit-sha': commitSha,
-      'commit-url': commitUrl,
-      'default-branch': defaultBranch,
-      'wait-for-deployment': waitForDeployment,
-      'max-execution-time': maxExecutionTime,
-    } = argv;
-    const author = parseCommitAuthor(argv.author);
-    const apiKey = getApiKeys(domain);
-    const filesToUpload = collectFilesToPush(argv.files || argv.apis);
-    const commandName = 'push' as const;
-
-    if (!filesToUpload.length) {
-      return printExecutionTime(commandName, startedAt, `No files to upload`);
-    }
-
-    const client = new ReuniteApi({ domain, apiKey, version, command: commandName });
-    const projectDefaultBranch = await client.remotes.getDefaultBranch(orgId, projectId);
-    const remote = await client.remotes.upsert(orgId, projectId, {
-      mountBranchName: projectDefaultBranch,
-      mountPath,
-    });
-
-    process.stderr.write(
-      `Uploading to ${remote.mountPath} ${filesToUpload.length} ${pluralize(
-        'file',
-        filesToUpload.length
-      )}:\n`
-    );
-
-    const { id } = await client.remotes.push(
-      orgId,
-      projectId,
-      {
-        remoteId: remote.id,
-        commit: {
-          message: argv.message,
-          branchName: argv.branch,
-          sha: commitSha,
-          url: commitUrl,
-          createdAt: argv['created-at'],
-          namespace: argv.namespace,
-          repository: argv.repository,
-          author,
-        },
-        isMainBranch: defaultBranch === argv.branch,
-      },
-      filesToUpload.map((f) => ({ path: slash(f.name), stream: fs.createReadStream(f.path) }))
-    );
-
-    filesToUpload.forEach((f) => {
-      process.stderr.write(green(`✓ ${f.name}\n`));
-    });
-
-    process.stdout.write('\n');
-    process.stdout.write(`Push ID: ${id}\n`);
-
-    if (waitForDeployment) {
-      process.stdout.write('\n');
-
-      await handlePushStatus({
-        argv: {
-          organization: orgId,
-          project: projectId,
-          pushId: id,
-          wait: true,
-          domain,
-          'max-execution-time': maxExecutionTime,
-          'start-time': startTime,
-          'continue-on-deploy-failures': argv['continue-on-deploy-failures'],
-        },
-        config,
-        version,
-      });
-    }
-    verbose &&
-      printExecutionTime(
-        commandName,
-        startedAt,
-        `${pluralize(
-          'file',
-          filesToUpload.length
-        )} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`
-      );
-
-    client.reportSunsetWarnings();
-
-    return {
-      pushId: id,
-    };
-  } catch (err) {
-    handleReuniteError('✗ File upload failed.', err);
-  }
-}
-
-function parseCommitAuthor(author: string): { name: string; email: string } {
-  // Author Name <author@email.com>
-  const reg = /^.+\s<[^<>]+>$/;
-
-  if (!reg.test(author)) {
-    throw new Error('Invalid author format. Use "Author Name <author@email.com>"');
-  }
-
-  const [name, email] = author.split('<');
-
-  return {
-    name: name.trim(),
-    email: email.replace('>', '').trim(),
-  };
-}
-
-function collectFilesToPush(files: string[]): FileToUpload[] {
-  const collectedFiles: Record<string, string> = {};
-
-  for (const file of files) {
-    if (fs.statSync(file).isDirectory()) {
-      const dir = file;
-      const fileList = getFilesList(dir, []);
-
-      fileList.forEach((f) => addFile(f, dir));
-    } else {
-      addFile(file, path.dirname(file));
-    }
-  }
-
-  function addFile(filePath: string, fileDir: string) {
-    const fileName = path.relative(fileDir, filePath);
-
-    if (collectedFiles[fileName]) {
-      process.stdout.write(
-        yellow(`File ${collectedFiles[fileName]} is overwritten by ${filePath}\n`)
-      );
-    }
-
-    collectedFiles[fileName] = filePath;
-  }
-
-  return Object.entries(collectedFiles).map(([name, filePath]) => getFileEntry(name, filePath));
-}
-
-function getFileEntry(name: string, filePath: string): FileToUpload {
-  return {
-    name,
-    path: path.resolve(filePath),
-  };
-}
-
-function getFilesList(dir: string, files: string[]): string[] {
-  const filesAndDirs = fs.readdirSync(dir);
-
-  for (const name of filesAndDirs) {
-    const currentPath = path.join(dir, name);
-
-    if (fs.statSync(currentPath).isDirectory()) {
-      files = getFilesList(currentPath, files);
-    } else {
-      files.push(currentPath);
-    }
-  }
-
-  return files;
-}

package/src/reunite/commands/utils.ts

@@ -1,66 +0,0 @@
-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.
- * 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();
-}
-
-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/reunite/utils.ts

@@ -1 +0,0 @@
-export class DeploymentError extends Error {}

package/src/types.ts

@@ -1,64 +0,0 @@
-import type { BundleOutputFormat, Region, Config, RuleSeverity } from '@redocly/openapi-core';
-import type { RespectOptions, GenerateArazzoFileOptions } from '@redocly/respect-core';
-import type { ArgumentsCamelCase } from 'yargs';
-import type { LintOptions } from './commands/lint';
-import type { BundleOptions } from './commands/bundle';
-import type { JoinOptions } from './commands/join';
-import type { LoginOptions, LogoutOptions } from './commands/auth';
-import type { PushOptions } from './commands/push';
-import type { StatsOptions } from './commands/stats';
-import type { SplitOptions } from './commands/split';
-import type { PreviewDocsOptions } from './commands/preview-docs';
-import type { BuildDocsArgv } from './commands/build-docs/types';
-import type { PushOptions as CMSPushOptions } from './reunite/commands/push';
-import type { PushStatusOptions } from './reunite/commands/push-status';
-import type { PreviewProjectOptions } from './commands/preview-project/types';
-import type { TranslationsOptions } from './commands/translations';
-import type { EjectOptions } from './commands/eject';
-
-export type Totals = {
-  errors: number;
-  warnings: number;
-  ignored: number;
-};
-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;
-export const regionChoices = ['us', 'eu'] as ReadonlyArray<Region>;
-export type CommandOptions =
-  | StatsOptions
-  | SplitOptions
-  | JoinOptions
-  | PushOptions
-  | CMSPushOptions
-  | LintOptions
-  | BundleOptions
-  | LoginOptions
-  | LogoutOptions
-  | PreviewDocsOptions
-  | BuildDocsArgv
-  | PushStatusOptions
-  | PreviewProjectOptions
-  | TranslationsOptions
-  | EjectOptions
-  | RespectOptions
-  | GenerateArazzoFileOptions;
-
-export type VerifyConfigOptions = {
-  config?: string;
-  'lint-config'?: RuleSeverity;
-};
-
-export type Skips = {
-  'skip-rule'?: string[];
-  'skip-decorator'?: string[];
-  'skip-preprocessor'?: string[];
-};
-
-export type ConfigApis = Pick<Config, 'apis' | 'configFile'>;
-
-export type PushArguments = ArgumentsCamelCase<PushOptions & CMSPushOptions & { apis: string[] }>;