@redocly/cli 1.7.0 → 1.8.0

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

@@ -0,0 +1,203 @@
+import * as colors from 'colorette';
+import { Config } 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 type { DeploymentStatus, PushResponse, ScorecardItem } from '../api/types';
+
+const INTERVAL = 5000;
+
+export type PushStatusOptions = {
+  organization: string;
+  project: string;
+  pushId: string;
+  domain?: string;
+  config?: string;
+  format?: 'stylish' | 'json';
+  wait?: boolean;
+  'max-execution-time': number;
+};
+
+export async function handlePushStatus(argv: PushStatusOptions, config: Config) {
+  const startedAt = performance.now();
+  const spinner = new Spinner();
+
+  const { organization, project: projectId, pushId, wait } = argv;
+
+  const orgId = organization || config.organization;
+
+  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_DOMAIN.`
+    );
+  }
+
+  const maxExecutionTime = argv['max-execution-time'] || 600;
+
+  try {
+    const apiKey = getApiKeys(domain);
+    const client = new ReuniteApiClient(domain, apiKey);
+
+    if (wait) {
+      const push = await waitForDeployment(client, 'preview');
+
+      if (push.isMainBranch && push.status.preview.deploy.status === 'success') {
+        await waitForDeployment(client, 'production');
+      }
+
+      printPushStatusInfo();
+      return;
+    }
+
+    const pushPreview = await getAndPrintPushStatus(client, 'preview');
+    printScorecard(pushPreview.status.preview.scorecard);
+
+    if (pushPreview.isMainBranch) {
+      await getAndPrintPushStatus(client, 'production');
+      printScorecard(pushPreview.status.production.scorecard);
+    }
+
+    printPushStatusInfo();
+  } catch (err) {
+    const message =
+      err instanceof DeploymentError
+        ? err.message
+        : `✗ Failed to get push status. Reason: ${err.message}\n`;
+    exitWithError(message);
+  }
+
+  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;
+          }
+
+          setTimeout(async () => {
+            try {
+              const pushResponse = await waitForDeployment(client, buildType);
+              resolve(pushResponse);
+            } catch (e) {
+              reject(e);
+            }
+          }, INTERVAL);
+        })
+        .catch(reject);
+    });
+  }
+
+  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(
+        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) {
+    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,
+  previewUrl,
+  spinner,
+  buildType,
+  wait,
+}: {
+  status: DeploymentStatus;
+  previewUrl: string | null;
+  spinner: Spinner;
+  buildType: 'preview' | 'production';
+  wait?: boolean;
+}) {
+  switch (status) {
+    case 'success':
+      spinner.stop();
+      return process.stdout.write(
+        `${colors.green(
+          `🚀 ${buildType.toLocaleUpperCase()} deployment succeeded.`
+        )}\n${colors.magenta('Preview URL')}: ${colors.cyan(previewUrl!)}\n`
+      );
+    case 'failed':
+      spinner.stop();
+      throw new DeploymentError(
+        `${colors.red(`❌ ${buildType.toLocaleUpperCase()} deployment failed.`)}\n${colors.magenta(
+          'Preview 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`);
+  }
+}

package/src/cms/commands/push.ts

@@ -0,0 +1,215 @@
+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 { green, yellow } from 'colorette';
+import pluralize = require('pluralize');
+import { handlePushStatus } from './push-status';
+import { ReuniteApiClient, getDomain, getApiKeys } from '../api';
+
+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;
+  config?: string;
+  'wait-for-deployment'?: boolean;
+  'max-execution-time': number;
+  verbose?: boolean;
+};
+
+type FileToUpload = { name: string; path: string };
+
+export async function handlePush(argv: PushOptions, config: Config) {
+  const startedAt = performance.now();
+  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 CMS');
+  }
+
+  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);
+
+    if (!filesToUpload.length) {
+      return printExecutionTime('push', startedAt, `No files to upload`);
+    }
+
+    const client = new ReuniteApiClient(domain, apiKey);
+    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(
+        {
+          organization: orgId,
+          project: projectId,
+          pushId: id,
+          wait: true,
+          domain,
+          'max-execution-time': maxExecutionTime,
+        },
+        config
+      );
+    }
+    verbose &&
+      printExecutionTime(
+        'push',
+        startedAt,
+        `${pluralize(
+          'file',
+          filesToUpload.length
+        )} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`
+      );
+  } catch (err) {
+    const message =
+      err instanceof HandledError ? '' : `✗ File upload failed. Reason: ${err.message}`;
+    exitWithError(message);
+  }
+}
+
+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/cms/utils.ts

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

package/src/commands/build-docs/index.ts

@@ -6,7 +6,7 @@ import { performance } from 'perf_hooks';
 import { getObjectOrJSON, getPageHTML } from './utils';
 import type { BuildDocsArgv } from './types';
 import { Config, getMergedConfig, isAbsoluteUrl } from '@redocly/openapi-core';
-import { exitWithError, getExecutionTime, getFallbackApisOrExit } from '../../utils';
+import { exitWithError, getExecutionTime, getFallbackApisOrExit } from '../../utils/miscellaneous';
 
 export const handlerBuildCommand = async (argv: BuildDocsArgv, configFromFile: Config) => {
   const startedAt = performance.now();

package/src/commands/build-docs/utils.ts

@@ -10,7 +10,7 @@ import { existsSync, lstatSync, readFileSync } from 'fs';
 
 import type { BuildDocsOptions } from './types';
 import { red } from 'colorette';
-import { exitWithError } from '../../utils';
+import { exitWithError } from '../../utils/miscellaneous';
 
 export function getObjectOrJSON(
   openapiOptions: string | Record<string, unknown>,

package/src/commands/bundle.ts

@@ -18,12 +18,12 @@ import {
   printLintTotals,
   checkIfRulesetExist,
   sortTopLevelKeysForOas,
-} from '../utils';
+} from '../utils/miscellaneous';
 import type { OutputExtensions, Skips, Totals } from '../types';
 import { performance } from 'perf_hooks';
 import { blue, gray, green, yellow } from 'colorette';
 import { writeFileSync } from 'fs';
-import { checkForDeprecatedOptions } from '../utils';
+import { checkForDeprecatedOptions } from '../utils/miscellaneous';
 
 export type BundleOptions = {
   apis?: string[];

package/src/commands/join.ts

@@ -30,8 +30,8 @@ import {
   getAndValidateFileExtension,
   writeToFileByExtension,
   checkForDeprecatedOptions,
-} from '../utils';
-import { isObject, isString, keysOf } from '../js-utils';
+} from '../utils/miscellaneous';
+import { isObject, isString, keysOf } from '../utils/js-utils';
 import {
   Oas3Parameter,
   Oas3PathItem,

package/src/commands/lint.ts

@@ -17,7 +17,7 @@ import {
   printConfigLintTotals,
   printLintTotals,
   printUnusedWarnings,
-} from '../utils';
+} from '../utils/miscellaneous';
 import { blue, gray } from 'colorette';
 import { performance } from 'perf_hooks';
 

package/src/commands/login.ts

@@ -1,6 +1,6 @@
 import { Region, RedoclyClient, Config } from '@redocly/openapi-core';
 import { blue, green, gray } from 'colorette';
-import { promptUser } from '../utils';
+import { promptUser } from '../utils/miscellaneous';
 
 export function promptClientToken(domain: string) {
   return promptUser(

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

@@ -1,7 +1,11 @@
 import * as colorette from 'colorette';
 import * as chockidar from 'chokidar';
 import { bundle, RedoclyClient, getTotals, getMergedConfig, Config } from '@redocly/openapi-core';
-import { getFallbackApisOrExit, handleError, loadConfigAndHandleErrors } from '../../utils';
+import {
+  getFallbackApisOrExit,
+  handleError,
+  loadConfigAndHandleErrors,
+} from '../../utils/miscellaneous';
 import startPreviewServer from './preview-server/preview-server';
 import type { Skips } from '../../types';
 

package/src/commands/preview-docs/preview-server/preview-server.ts

@@ -6,7 +6,7 @@ import * as path from 'path';
 
 import { startHttpServer, startWsServer, respondWithGzip, mimeTypes } from './server';
 import type { IncomingMessage } from 'http';
-import { isSubdir } from '../../../utils';
+import { isSubdir } from '../../../utils/miscellaneous';
 
 function getPageHTML(
   htmlTemplate: string,

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

@@ -8,5 +8,5 @@ export type PreviewProjectOptions = {
   plan: ProductPlan | string;
   port?: number;
   'source-dir': string;
-  config: string | undefined;
+  config?: string;
 };

package/src/commands/push.ts

@@ -21,8 +21,9 @@ import {
   getFallbackApisOrExit,
   pluralize,
   dumpBundle,
-} from '../utils';
+} from '../utils/miscellaneous';
 import { promptClientToken } from './login';
+import { handlePush as handleCMSPush } from '../cms/commands/push';
 
 const DEFAULT_VERSION = 'latest';
 
@@ -44,6 +45,19 @@ export type PushOptions = {
   config?: string;
 };
 
+export function commonPushHandler({
+  project,
+  'mount-path': mountPath,
+}: {
+  project?: string;
+  'mount-path'?: string;
+}) {
+  if (project && mountPath) {
+    return handleCMSPush;
+  }
+  return handlePush;
+}
+
 export async function handlePush(argv: PushOptions, config: Config): Promise<void> {
   const client = new RedoclyClient(config.region);
   const isAuthorized = await client.isAuthorizedWithRedoclyByRegion();

package/src/commands/split/__tests__/index.test.ts

@@ -3,12 +3,11 @@ import * as path from 'path';
 import * as openapiCore from '@redocly/openapi-core';
 import { ComponentsFiles } from '../types';
 import { blue, green } from 'colorette';
-import { writeToFileByExtension } from '../../../utils';
 
-const utils = require('../../../utils');
+const utils = require('../../../utils/miscellaneous');
 
-jest.mock('../../../utils', () => ({
-  ...jest.requireActual('../../../utils'),
+jest.mock('../../../utils/miscellaneous', () => ({
+  ...jest.requireActual('../../../utils/miscellaneous'),
   writeToFileByExtension: jest.fn(),
 }));
 

package/src/commands/split/index.ts

@@ -15,8 +15,8 @@ import {
   langToExt,
   writeToFileByExtension,
   getAndValidateFileExtension,
-} from '../../utils';
-import { isString, isObject, isEmptyObject } from '../../js-utils';
+} from '../../utils/miscellaneous';
+import { isString, isObject, isEmptyObject } from '../../utils/js-utils';
 import {
   Definition,
   Oas2Definition,

package/src/commands/stats.ts

@@ -13,8 +13,8 @@ import {
   Stats,
   bundle,
 } from '@redocly/openapi-core';
-import { getFallbackApisOrExit } from '../utils';
-import { printExecutionTime } from '../utils';
+import { getFallbackApisOrExit } from '../utils/miscellaneous';
+import { printExecutionTime } from '../utils/miscellaneous';
 import type { StatsAccumulator, StatsName, WalkContext, OutputFormat } from '@redocly/openapi-core';
 
 const statsAccumulator: StatsAccumulator = {