@redocly/cli 1.7.0 → 1.8.1

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

@@ -0,0 +1,226 @@
+"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 fs = require("fs");
+const path = require("path");
+const push_1 = require("../push");
+const api_1 = require("../../api");
+const remotes = {
+    push: jest.fn(),
+    upsert: jest.fn(),
+    getDefaultBranch: jest.fn(),
+};
+jest.mock('@redocly/openapi-core', () => ({
+    slash: jest.fn().mockImplementation((p) => p),
+}));
+jest.mock('../../api', () => (Object.assign(Object.assign({}, jest.requireActual('../../api')), { ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
+        this.remotes = remotes;
+    }) })));
+describe('handlePush()', () => {
+    let pathResolveSpy;
+    let pathRelativeSpy;
+    let pathDirnameSpy;
+    let fsStatSyncSpy;
+    let fsReaddirSyncSpy;
+    beforeEach(() => {
+        remotes.getDefaultBranch.mockResolvedValueOnce('test-default-branch');
+        remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id' });
+        remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch' });
+        jest.spyOn(fs, 'createReadStream').mockReturnValue('stream');
+        pathResolveSpy = jest.spyOn(path, 'resolve');
+        pathRelativeSpy = jest.spyOn(path, 'relative');
+        pathDirnameSpy = jest.spyOn(path, 'dirname');
+        fsStatSyncSpy = jest.spyOn(fs, 'statSync');
+        fsReaddirSyncSpy = jest.spyOn(fs, 'readdirSync');
+    });
+    afterEach(() => {
+        pathResolveSpy.mockRestore();
+        pathRelativeSpy.mockRestore();
+        pathDirnameSpy.mockRestore();
+        fsStatSyncSpy.mockRestore();
+        fsReaddirSyncSpy.mockRestore();
+    });
+    it('should upload files', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockConfig = { apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        fsStatSyncSpy.mockReturnValueOnce({
+            isDirectory() {
+                return false;
+            },
+        });
+        pathResolveSpy.mockImplementationOnce((p) => p);
+        pathRelativeSpy.mockImplementationOnce((_, p) => p);
+        pathDirnameSpy.mockImplementation((_) => '.');
+        yield (0, push_1.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(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org', 'test-project');
+        expect(remotes.upsert).toHaveBeenCalledWith('test-org', 'test-project', {
+            mountBranchName: 'test-default-branch',
+            mountPath: 'test-mount-path',
+        });
+        expect(remotes.push).toHaveBeenCalledWith('test-org', 'test-project', {
+            isMainBranch: true,
+            remoteId: 'test-remote-id',
+            commit: {
+                message: 'Test message',
+                branchName: 'test-branch',
+                createdAt: 'test-created-at',
+                namespace: 'test-namespace',
+                repository: 'test-repository',
+                sha: 'test-commit-sha',
+                url: 'test-commit-url',
+                author: {
+                    name: 'TestAuthor',
+                    email: 'test-author@mail.com',
+                },
+            },
+        }, [
+            {
+                path: 'test-file',
+                stream: 'stream',
+            },
+        ]);
+    }));
+    it('should collect files from directory and preserve file structure', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockConfig = { apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        /*
+          ├── app
+          │   ├── index.html
+          ├── openapi.yaml
+          └── some-ref.yaml
+        */
+        fsStatSyncSpy.mockImplementation((filePath) => ({
+            isDirectory() {
+                return filePath === 'test-folder' || filePath === 'test-folder/app';
+            },
+        }));
+        fsReaddirSyncSpy.mockImplementation((dirPath) => {
+            if (dirPath === 'test-folder') {
+                return ['app', 'another-ref.yaml', 'openapi.yaml'];
+            }
+            if (dirPath === 'test-folder/app') {
+                return ['index.html'];
+            }
+            throw new Error('Not a directory');
+        });
+        yield (0, push_1.handlePush)({
+            domain: 'test-domain',
+            'mount-path': 'test-mount-path',
+            organization: 'test-org',
+            project: 'test-project',
+            branch: 'test-branch',
+            author: 'TestAuthor <test-author@mail.com>',
+            message: 'Test message',
+            'default-branch': 'main',
+            files: ['test-folder'],
+            'max-execution-time': 10,
+        }, mockConfig);
+        expect(remotes.push).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), [
+            {
+                path: 'app/index.html',
+                stream: 'stream',
+            },
+            {
+                path: 'another-ref.yaml',
+                stream: 'stream',
+            },
+            {
+                path: 'openapi.yaml',
+                stream: 'stream',
+            },
+        ]);
+    }));
+    it('should not upload files if no files passed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockConfig = { apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        yield (0, push_1.handlePush)({
+            domain: 'test-domain',
+            'mount-path': 'test-mount-path',
+            organization: 'test-org',
+            project: 'test-project',
+            branch: 'test-branch',
+            author: 'TestAuthor <test-author@mail.com>',
+            message: 'Test message',
+            'default-branch': 'main',
+            files: [],
+            'max-execution-time': 10,
+        }, mockConfig);
+        expect(remotes.getDefaultBranch).not.toHaveBeenCalled();
+        expect(remotes.upsert).not.toHaveBeenCalled();
+        expect(remotes.push).not.toHaveBeenCalled();
+    }));
+    it('should get organization from config if not passed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockConfig = { organization: 'test-org-from-config', apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        fsStatSyncSpy.mockReturnValueOnce({
+            isDirectory() {
+                return false;
+            },
+        });
+        pathResolveSpy.mockImplementationOnce((p) => p);
+        pathRelativeSpy.mockImplementationOnce((_, p) => p);
+        pathDirnameSpy.mockImplementation((_) => '.');
+        yield (0, push_1.handlePush)({
+            domain: 'test-domain',
+            'mount-path': 'test-mount-path',
+            project: 'test-project',
+            branch: 'test-branch',
+            author: 'TestAuthor <test-author@mail.com>',
+            message: 'Test message',
+            files: ['test-file'],
+            'default-branch': 'main',
+            'max-execution-time': 10,
+        }, mockConfig);
+        expect(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org-from-config', expect.anything());
+        expect(remotes.upsert).toHaveBeenCalledWith('test-org-from-config', expect.anything(), expect.anything());
+        expect(remotes.push).toHaveBeenCalledWith('test-org-from-config', expect.anything(), expect.anything(), expect.anything());
+    }));
+    it('should get domain from env if not passed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockConfig = { organization: 'test-org-from-config', apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        process.env.REDOCLY_DOMAIN = 'test-domain-from-env';
+        fsStatSyncSpy.mockReturnValueOnce({
+            isDirectory() {
+                return false;
+            },
+        });
+        pathResolveSpy.mockImplementationOnce((p) => p);
+        pathRelativeSpy.mockImplementationOnce((_, p) => p);
+        pathDirnameSpy.mockImplementation((_) => '.');
+        yield (0, push_1.handlePush)({
+            'mount-path': 'test-mount-path',
+            project: 'test-project',
+            branch: 'test-branch',
+            'default-branch': 'main',
+            author: 'TestAuthor <test-author@mail.com>',
+            message: 'Test message',
+            files: ['test-file'],
+            'max-execution-time': 10,
+        }, mockConfig);
+        expect(api_1.ReuniteApiClient).toBeCalledWith('test-domain-from-env', 'test-api-key');
+    }));
+});

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

@@ -0,0 +1,12 @@
+import { Config } from '@redocly/openapi-core';
+export type PushStatusOptions = {
+    organization: string;
+    project: string;
+    pushId: string;
+    domain?: string;
+    config?: string;
+    format?: 'stylish' | 'json';
+    wait?: boolean;
+    'max-execution-time': number;
+};
+export declare function handlePushStatus(argv: PushStatusOptions, config: Config): Promise<void>;

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

@@ -0,0 +1,150 @@
+"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.handlePushStatus = void 0;
+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 INTERVAL = 5000;
+function handlePushStatus(argv, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const startedAt = performance.now();
+        const spinner = new spinner_1.Spinner();
+        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.`);
+        }
+        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;
+        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;
+            }
+            const pushPreview = yield getAndPrintPushStatus(client, 'preview');
+            printScorecard(pushPreview.status.preview.scorecard);
+            if (pushPreview.isMainBranch) {
+                yield getAndPrintPushStatus(client, 'production');
+                printScorecard(pushPreview.status.production.scorecard);
+            }
+            printPushStatusInfo();
+        }
+        catch (err) {
+            const message = err instanceof utils_1.DeploymentError
+                ? err.message
+                : `✗ Failed to get push status. Reason: ${err.message}\n`;
+            (0, miscellaneous_1.exitWithError)(message);
+        }
+        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;
+            });
+        }
+    });
+}
+exports.handlePushStatus = handlePushStatus;
+function printScorecard(scorecard) {
+    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, }) {
+    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 utils_1.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/lib/cms/commands/push.d.ts

@@ -0,0 +1,23 @@
+import { Config } from '@redocly/openapi-core';
+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;
+};
+export declare function handlePush(argv: PushOptions, config: Config): Promise<void>;

package/lib/cms/commands/push.js

@@ -0,0 +1,142 @@
+"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.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 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 { organization, project: projectId, 'mount-path': mountPath, verbose } = argv;
+        const orgId = organization || config.organization;
+        if (!argv.message || !argv.author || !argv.branch) {
+            (0, miscellaneous_1.exitWithError)('Error: message, author and branch are required for push to the CMS');
+        }
+        if (!orgId) {
+            return (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+        }
+        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_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 = (0, api_1.getApiKeys)(domain);
+            const filesToUpload = collectFilesToPush(argv.files || argv.apis);
+            if (!filesToUpload.length) {
+                return (0, miscellaneous_1.printExecutionTime)('push', startedAt, `No files to upload`);
+            }
+            const client = new api_1.ReuniteApiClient(domain, apiKey);
+            const projectDefaultBranch = yield client.remotes.getDefaultBranch(orgId, projectId);
+            const remote = yield client.remotes.upsert(orgId, projectId, {
+                mountBranchName: projectDefaultBranch,
+                mountPath,
+            });
+            process.stderr.write(`Uploading to ${remote.mountPath} ${filesToUpload.length} ${pluralize('file', filesToUpload.length)}:\n`);
+            const { id } = yield 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: (0, openapi_core_1.slash)(f.name), stream: fs.createReadStream(f.path) })));
+            filesToUpload.forEach((f) => {
+                process.stderr.write((0, colorette_1.green)(`✓ ${f.name}\n`));
+            });
+            process.stdout.write('\n');
+            process.stdout.write(`Push ID: ${id}\n`);
+            if (waitForDeployment) {
+                process.stdout.write('\n');
+                yield (0, push_status_1.handlePushStatus)({
+                    organization: orgId,
+                    project: projectId,
+                    pushId: id,
+                    wait: true,
+                    domain,
+                    'max-execution-time': maxExecutionTime,
+                }, config);
+            }
+            verbose &&
+                (0, miscellaneous_1.printExecutionTime)('push', startedAt, `${pluralize('file', filesToUpload.length)} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`);
+        }
+        catch (err) {
+            const message = err instanceof miscellaneous_1.HandledError ? '' : `✗ File upload failed. Reason: ${err.message}`;
+            (0, miscellaneous_1.exitWithError)(message);
+        }
+    });
+}
+exports.handlePush = handlePush;
+function parseCommitAuthor(author) {
+    // 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) {
+    const collectedFiles = {};
+    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, fileDir) {
+        const fileName = path.relative(fileDir, filePath);
+        if (collectedFiles[fileName]) {
+            process.stdout.write((0, colorette_1.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, filePath) {
+    return {
+        name,
+        path: path.resolve(filePath),
+    };
+}
+function getFilesList(dir, files) {
+    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/lib/cms/utils.d.ts

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

package/lib/cms/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentError = void 0;
+class DeploymentError extends Error {
+}
+exports.DeploymentError = DeploymentError;

package/lib/commands/build-docs/index.js

@@ -16,12 +16,12 @@ const fs_1 = require("fs");
 const perf_hooks_1 = require("perf_hooks");
 const utils_1 = require("./utils");
 const openapi_core_1 = require("@redocly/openapi-core");
-const utils_2 = require("../../utils");
+const miscellaneous_1 = require("../../utils/miscellaneous");
 const handlerBuildCommand = (argv, configFromFile) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const startedAt = perf_hooks_1.performance.now();
     const config = (0, openapi_core_1.getMergedConfig)(configFromFile, argv.api);
-    const apis = yield (0, utils_2.getFallbackApisOrExit)(argv.api ? [argv.api] : [], config);
+    const apis = yield (0, miscellaneous_1.getFallbackApisOrExit)(argv.api ? [argv.api] : [], config);
     const { path: pathToApi } = apis[0];
     const options = {
         output: argv.o,
@@ -33,7 +33,7 @@ const handlerBuildCommand = (argv, configFromFile) => __awaiter(void 0, void 0,
     };
     const redocCurrentVersion = require('../../../package.json').dependencies.redoc.substring(1); // remove ~
     try {
-        const elapsed = (0, utils_2.getExecutionTime)(startedAt);
+        const elapsed = (0, miscellaneous_1.getExecutionTime)(startedAt);
         const api = yield (0, redoc_1.loadAndBundleSpec)((0, openapi_core_1.isAbsoluteUrl)(pathToApi) ? pathToApi : (0, path_1.resolve)(pathToApi));
         const pageHTML = yield (0, utils_1.getPageHTML)(api, pathToApi, Object.assign(Object.assign({}, options), { redocCurrentVersion }), argv.config);
         (0, fs_1.mkdirSync)((0, path_1.dirname)(options.output), { recursive: true });
@@ -42,7 +42,7 @@ const handlerBuildCommand = (argv, configFromFile) => __awaiter(void 0, void 0,
         process.stdout.write(`\n🎉 bundled successfully in: ${options.output} (${sizeInKiB} KiB) [⏱ ${elapsed}].\n`);
     }
     catch (e) {
-        (0, utils_2.exitWithError)(e);
+        (0, miscellaneous_1.exitWithError)(e);
     }
 });
 exports.handlerBuildCommand = handlerBuildCommand;

package/lib/commands/build-docs/utils.js

@@ -19,7 +19,7 @@ const handlebars_1 = require("handlebars");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const colorette_1 = require("colorette");
-const utils_1 = require("../../utils");
+const miscellaneous_1 = require("../../utils/miscellaneous");
 function getObjectOrJSON(openapiOptions, config) {
     switch (typeof openapiOptions) {
         case 'object':
@@ -35,7 +35,7 @@ function getObjectOrJSON(openapiOptions, config) {
             }
             catch (e) {
                 process.stderr.write((0, colorette_1.red)(`Encountered error:\n\n${openapiOptions}\n\nis neither a file with a valid JSON object neither a stringified JSON object.`));
-                (0, utils_1.exitWithError)(e);
+                (0, miscellaneous_1.exitWithError)(e);
             }
             break;
         default: {