@redocly/cli 1.11.0 → 1.12.1

package/lib/cms/commands/__tests__/utils.test.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+jest.mock('@redocly/openapi-core', () => ({
+    pause: jest.requireActual('@redocly/openapi-core').pause,
+}));
+describe('retryUntilConditionMet()', () => {
+    it('should retry until condition meet and return result', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operation = jest
+            .fn()
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'done' });
+        const data = yield (0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+        });
+        expect(data).toEqual({ status: 'done' });
+    }));
+    it('should throw error if condition not meet for desired timeout', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operation = jest.fn().mockResolvedValue({ status: 'pending' });
+        yield expect((0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+        })).rejects.toThrow('Timeout exceeded');
+    }));
+    it('should call "onConditionNotMet" and "onRetry" callbacks', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operation = jest
+            .fn()
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'done' });
+        const onConditionNotMet = jest.fn();
+        const onRetry = jest.fn();
+        const data = yield (0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+            onConditionNotMet,
+            onRetry,
+        });
+        expect(data).toEqual({ status: 'done' });
+        expect(onConditionNotMet).toHaveBeenCalledTimes(2);
+        expect(onRetry).toHaveBeenCalledTimes(2);
+    }));
+});

package/lib/cms/commands/push-status.d.ts

@@ -1,12 +1,22 @@
-import { Config } from '@redocly/openapi-core';
+import type { Config, OutputFormat } from '@redocly/openapi-core';
+import type { DeploymentStatusResponse, PushResponse } from '../api/types';
 export type PushStatusOptions = {
     organization: string;
     project: string;
     pushId: string;
     domain?: string;
     config?: string;
-    format?: 'stylish' | 'json';
+    format?: Extract<OutputFormat, 'stylish'>;
     wait?: boolean;
-    'max-execution-time': number;
+    'max-execution-time'?: number;
+    'retry-interval'?: number;
+    'start-time'?: number;
+    'continue-on-deploy-failures'?: boolean;
+    onRetry?: (lasSummary: PushStatusSummary) => void;
 };
-export declare function handlePushStatus(argv: PushStatusOptions, config: Config): Promise<void>;
+export interface PushStatusSummary {
+    preview: DeploymentStatusResponse;
+    production: DeploymentStatusResponse | null;
+    commit: PushResponse['commit'];
+}
+export declare function handlePushStatus(argv: PushStatusOptions, config: Config): Promise<PushStatusSummary | undefined>;

package/lib/cms/commands/push-status.js

@@ -14,10 +14,10 @@ const colors = require("colorette");
 const miscellaneous_1 = require("../../utils/miscellaneous");
 const spinner_1 = require("../../utils/spinner");
 const utils_1 = require("../utils");
-const colorette_1 = require("colorette");
 const api_1 = require("../api");
 const js_utils_1 = require("../../utils/js-utils");
-const INTERVAL = 5000;
+const utils_2 = require("./utils");
+const RETRY_INTERVAL_MS = 5000; // 5 sec
 function handlePushStatus(argv, config) {
     return __awaiter(this, void 0, void 0, function* () {
         const startedAt = performance.now();
@@ -25,97 +25,154 @@ function handlePushStatus(argv, config) {
         const { organization, project: projectId, pushId, wait } = argv;
         const orgId = organization || config.organization;
         if (!orgId) {
-            return (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+            (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+            return;
         }
         const domain = argv.domain || (0, api_1.getDomain)();
-        if (!domain) {
-            return (0, miscellaneous_1.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 = (0, api_1.getApiKeys)(domain);
             const client = new api_1.ReuniteApiClient(domain, apiKey);
-            if (wait) {
-                const push = yield waitForDeployment(client, 'preview');
-                if (push.isMainBranch && push.status.preview.deploy.status === 'success') {
-                    yield waitForDeployment(client, 'production');
-                }
-                printPushStatusInfo();
-                return;
+            let pushResponse;
+            pushResponse = yield (0, utils_2.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 = yield (0, utils_2.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,
+                });
             }
-            const pushPreview = yield getAndPrintPushStatus(client, 'preview');
-            printScorecard(pushPreview.status.preview.scorecard);
-            if (pushPreview.isMainBranch) {
-                yield getAndPrintPushStatus(client, 'production');
-                printScorecard(pushPreview.status.production.scorecard);
+            if (pushResponse.isMainBranch) {
+                printPushStatus({
+                    buildType: 'production',
+                    spinner,
+                    wait,
+                    push: pushResponse,
+                    continueOnDeployFailures,
+                });
+                printScorecard(pushResponse.status.production.scorecard);
             }
-            printPushStatusInfo();
+            printPushStatusInfo({ orgId, projectId, pushId, startedAt });
+            const summary = {
+                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 utils_1.DeploymentError
                 ? err.message
                 : `✗ Failed to get push status. Reason: ${err.message}\n`;
             (0, miscellaneous_1.exitWithError)(message);
+            return;
         }
-        function printPushStatusInfo() {
-            process.stderr.write(`\nProcessed push-status for ${colors.yellow(orgId)}, ${colors.yellow(projectId)} and pushID ${colors.yellow(pushId)}.\n`);
-            (0, miscellaneous_1.printExecutionTime)('push-status', startedAt, 'Finished');
-        }
-        function waitForDeployment(client, buildType) {
-            return __awaiter(this, void 0, void 0, function* () {
-                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(() => __awaiter(this, void 0, void 0, function* () {
-                            try {
-                                const pushResponse = yield waitForDeployment(client, buildType);
-                                resolve(pushResponse);
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        }), INTERVAL);
-                    })
-                        .catch(reject);
-                });
-            });
-        }
-        function getAndPrintPushStatus(client, buildType) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const push = yield client.remotes.getPush({
-                    organizationId: orgId,
-                    projectId,
-                    pushId,
-                });
-                if (push.isOutdated || !push.hasChanges) {
-                    process.stderr.write((0, colorette_1.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;
-            });
+        finally {
+            spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
         }
     });
 }
 exports.handlePushStatus = handlePushStatus;
+function printPushStatusInfo({ orgId, projectId, pushId, startedAt, }) {
+    process.stderr.write(`\nProcessed push-status for ${colors.yellow(orgId)}, ${colors.yellow(projectId)} and pushID ${colors.yellow(pushId)}.\n`);
+    (0, miscellaneous_1.printExecutionTime)('push-status', startedAt, 'Finished');
+}
+function printPushStatus({ buildType, spinner, push, continueOnDeployFailures, }) {
+    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) {
-    if (!scorecard.length) {
+    if (!scorecard || scorecard.length === 0) {
         return;
     }
     process.stdout.write(`\n${colors.magenta('Scorecard')}:`);
@@ -128,24 +185,37 @@ function printScorecard(scorecard) {
     }
     process.stdout.write(`\n`);
 }
-function displayDeploymentAndBuildStatus({ status, previewUrl, spinner, buildType, wait, }) {
+function displayDeploymentAndBuildStatus({ status, url, spinner, buildType, continueOnDeployFailures, wait, }) {
+    const message = getMessage({ status, url, buildType, wait });
+    if (status === 'failed' && !continueOnDeployFailures) {
+        spinner.stop();
+        throw new utils_1.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, }) {
     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(`🚀 ${(0, js_utils_1.capitalize)(buildType)} deploy success.`)}\n${colors.magenta(`${(0, js_utils_1.capitalize)(buildType)} URL`)}: ${colors.cyan(previewUrl)}\n`);
+            return `${colors.green(`🚀 ${(0, js_utils_1.capitalize)(buildType)} deploy success.`)}\n${colors.magenta(`${(0, js_utils_1.capitalize)(buildType)} URL`)}: ${colors.cyan(url || 'No URL yet.')}\n`;
         case 'failed':
-            spinner.stop();
-            throw new utils_1.DeploymentError(`${colors.red(`❌ ${(0, js_utils_1.capitalize)(buildType)} deploy fail.`)}\n${colors.magenta(`${(0, js_utils_1.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(`❌ ${(0, js_utils_1.capitalize)(buildType)} deploy fail.`)}\n${colors.magenta(`${(0, js_utils_1.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/lib/cms/commands/push.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '@redocly/openapi-core';
+import type { OutputFormat, Config } from '@redocly/openapi-core';
 export type PushOptions = {
     apis?: string[];
     organization?: string;
@@ -18,6 +18,10 @@ export type PushOptions = {
     config?: string;
     'wait-for-deployment'?: boolean;
     'max-execution-time': number;
+    'continue-on-deploy-failures'?: boolean;
     verbose?: boolean;
+    format?: Extract<OutputFormat, 'stylish'>;
 };
-export declare function handlePush(argv: PushOptions, config: Config): Promise<void>;
+export declare function handlePush(argv: PushOptions, config: Config): Promise<{
+    pushId: string;
+} | void>;

package/lib/cms/commands/push.js

@@ -13,14 +13,15 @@ exports.handlePush = void 0;
 const fs = require("fs");
 const path = require("path");
 const openapi_core_1 = require("@redocly/openapi-core");
-const miscellaneous_1 = require("../../utils/miscellaneous");
 const colorette_1 = require("colorette");
 const pluralize = require("pluralize");
+const miscellaneous_1 = require("../../utils/miscellaneous");
 const push_status_1 = require("./push-status");
 const api_1 = require("../api");
 function handlePush(argv, config) {
     return __awaiter(this, void 0, void 0, function* () {
-        const startedAt = performance.now();
+        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) {
@@ -76,10 +77,15 @@ function handlePush(argv, config) {
                     wait: true,
                     domain,
                     'max-execution-time': maxExecutionTime,
+                    'start-time': startTime,
+                    'continue-on-deploy-failures': argv['continue-on-deploy-failures'],
                 }, config);
             }
             verbose &&
                 (0, miscellaneous_1.printExecutionTime)('push', startedAt, `${pluralize('file', filesToUpload.length)} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`);
+            return {
+                pushId: id,
+            };
         }
         catch (err) {
             const message = err instanceof miscellaneous_1.HandledError ? '' : `✗ File upload failed. Reason: ${err.message}`;

package/lib/cms/commands/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 declare function retryUntilConditionMet<T>({ operation, condition, onConditionNotMet, onRetry, startTime, retryTimeoutMs, // 10 min
+retryIntervalMs, }: {
+    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>;

package/lib/cms/commands/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryUntilConditionMet = void 0;
+const openapi_core_1 = require("@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.
+ */
+function retryUntilConditionMet({ operation, condition, onConditionNotMet, onRetry, startTime = Date.now(), retryTimeoutMs = 600000, // 10 min
+retryIntervalMs = 5000, // 5 sec
+ }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        function attempt() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const result = yield operation();
+                if (!condition) {
+                    return result;
+                }
+                if (condition(result)) {
+                    return result;
+                }
+                else if (Date.now() - startTime > retryTimeoutMs) {
+                    throw new Error('Timeout exceeded');
+                }
+                else {
+                    onConditionNotMet === null || onConditionNotMet === void 0 ? void 0 : onConditionNotMet(result);
+                    yield (0, openapi_core_1.pause)(retryIntervalMs);
+                    yield (onRetry === null || onRetry === void 0 ? void 0 : onRetry(result));
+                    return attempt();
+                }
+            });
+        }
+        return attempt();
+    });
+}
+exports.retryUntilConditionMet = retryUntilConditionMet;

package/lib/index.js

@@ -174,9 +174,10 @@ yargs
     project: {
         description: 'Name of the project to push to.',
         type: 'string',
+        required: true,
         alias: 'p',
     },
-    domain: { description: 'Specify a domain.', alias: 'd', type: 'string' },
+    domain: { description: 'Specify a domain.', alias: 'd', type: 'string', required: false },
     wait: {
         description: 'Wait for build to finish.',
         type: 'boolean',
@@ -186,6 +187,11 @@ yargs
         description: 'Maximum execution time in seconds.',
         type: 'number',
     },
+    'continue-on-deploy-failures': {
+        description: 'Command does not fail even if the deployment fails.',
+        type: 'boolean',
+        default: false,
+    },
 }), (argv) => {
     process.env.REDOCLY_CLI_COMMAND = 'push-status';
     (0, wrapper_1.commandWrapper)(push_status_1.handlePushStatus)(argv);
@@ -339,6 +345,11 @@ yargs
         type: 'boolean',
         default: false,
     },
+    'continue-on-deploy-failures': {
+        description: 'Command does not fail even if the deployment fails.',
+        type: 'boolean',
+        default: false,
+    },
 }), (argv) => {
     process.env.REDOCLY_CLI_COMMAND = 'push';
     (0, wrapper_1.commandWrapper)((0, push_1.commonPushHandler)(argv))(argv);

package/lib/utils/miscellaneous.js

@@ -30,6 +30,7 @@ const fs = require("fs");
 const readline = require("readline");
 const stream_1 = require("stream");
 const child_process_1 = require("child_process");
+const util_1 = require("util");
 const openapi_core_1 = require("@redocly/openapi-core");
 const types_1 = require("../types");
 const utils_1 = require("@redocly/openapi-core/lib/utils");
@@ -89,7 +90,7 @@ function expandGlobsInEntrypoints(args, config) {
     return __awaiter(this, void 0, void 0, function* () {
         return (yield Promise.all(args.map((aliasOrPath) => __awaiter(this, void 0, void 0, function* () {
             return glob.hasMagic(aliasOrPath) && !(0, openapi_core_1.isAbsoluteUrl)(aliasOrPath)
-                ? (yield glob.__promisify__(aliasOrPath)).map((g) => getAliasOrPath(config, g))
+                ? (yield (0, util_1.promisify)(glob)(aliasOrPath)).map((g) => getAliasOrPath(config, g))
                 : getAliasOrPath(config, aliasOrPath);
         })))).flat();
     });
@@ -270,9 +271,9 @@ function handleError(e, ref) {
             throw e;
         }
         case openapi_core_1.ResolveError:
-            return exitWithError(`Failed to resolve API description at ${ref}:\n\n  - ${e.message}.`);
+            return exitWithError(`Failed to resolve API description at ${ref}:\n\n  - ${e.message}`);
         case openapi_core_1.YamlParseError:
-            return exitWithError(`Failed to parse API description at ${ref}:\n\n  - ${e.message}.`);
+            return exitWithError(`Failed to parse API description at ${ref}:\n\n  - ${e.message}`);
         case CircularJSONNotSupportedError: {
             return exitWithError(`Detected circular reference which can't be converted to JSON.\n` +
                 `Try to use ${(0, colorette_1.blue)('yaml')} output or remove ${(0, colorette_1.blue)('--dereferenced')}.`);
@@ -282,7 +283,7 @@ function handleError(e, ref) {
         case config_1.ConfigValidationError:
             return exitWithError(e.message);
         default: {
-            exitWithError(`Something went wrong when processing ${ref}:\n\n  - ${e.message}.`);
+            exitWithError(`Something went wrong when processing ${ref}:\n\n  - ${e.message}`);
         }
     }
 }

package/lib/wrapper.d.ts

@@ -1,4 +1,4 @@
 import { Config } from '@redocly/openapi-core';
 import type { Arguments } from 'yargs';
 import type { CommandOptions } from './types';
-export declare function commandWrapper<T extends CommandOptions>(commandHandler?: (argv: T, config: Config, version: string) => Promise<void>): (argv: Arguments<T>) => Promise<void>;
+export declare function commandWrapper<T extends CommandOptions>(commandHandler?: (argv: T, config: Config, version: string) => Promise<unknown>): (argv: Arguments<T>) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/cli",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "description": "",
   "license": "MIT",
   "bin": {
@@ -36,7 +36,7 @@
     "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/openapi-core": "1.11.0",
+    "@redocly/openapi-core": "1.12.1",
     "abort-controller": "^3.0.0",
     "chokidar": "^3.5.1",
     "colorette": "^1.2.0",

package/src/__tests__/utils.test.ts

@@ -415,7 +415,7 @@ describe('handleErrors', () => {
   });
 
   it('should handle ResolveError', () => {
-    const resolveError = new ResolveError(new Error('File not found'));
+    const resolveError = new ResolveError(new Error('File not found.'));
     expect(() => handleError(resolveError, ref)).toThrowError(HandledError);
     expect(redColoretteMocks).toHaveBeenCalledTimes(1);
     expect(process.stderr.write).toHaveBeenCalledWith(
@@ -424,7 +424,7 @@ describe('handleErrors', () => {
   });
 
   it('should handle YamlParseError', () => {
-    const yamlParseError = new YamlParseError(new Error('Invalid yaml'), {} as any);
+    const yamlParseError = new YamlParseError(new Error('Invalid yaml.'), {} as any);
     expect(() => handleError(yamlParseError, ref)).toThrowError(HandledError);
     expect(redColoretteMocks).toHaveBeenCalledTimes(1);
     expect(process.stderr.write).toHaveBeenCalledWith(
@@ -451,7 +451,7 @@ describe('handleErrors', () => {
   });
 
   it('should throw unknown error', () => {
-    const testError = new Error('Test error');
+    const testError = new Error('Test error.');
     expect(() => handleError(testError, ref)).toThrowError(HandledError);
     expect(process.stderr.write).toHaveBeenCalledWith(
       `Something went wrong when processing openapi/test.yaml:\n\n  - Test error.\n\n`