@redocly/cli 0.0.0-snapshot.1737554067

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

@@ -0,0 +1,315 @@
+"use strict";
+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', () => ({
+    ...jest.requireActual('../../api'),
+    ReuniteApi: jest.fn().mockImplementation(function (...args) {
+        this.remotes = remotes;
+        this.reportSunsetWarnings = jest.fn();
+    }),
+}));
+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', mountPath: 'test-mount-path' });
+        remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch', id: 'test-id' });
+        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', async () => {
+        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((_) => '.');
+        await (0, push_1.handlePush)({
+            argv: {
+                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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        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 return push id', async () => {
+        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((_) => '.');
+        const result = await (0, push_1.handlePush)({
+            argv: {
+                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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(result).toEqual({ pushId: 'test-id' });
+    });
+    it('should collect files from directory and preserve file structure', async () => {
+        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');
+        });
+        await (0, push_1.handlePush)({
+            argv: {
+                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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        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', async () => {
+        const mockConfig = { apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        await (0, push_1.handlePush)({
+            argv: {
+                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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(remotes.getDefaultBranch).not.toHaveBeenCalled();
+        expect(remotes.upsert).not.toHaveBeenCalled();
+        expect(remotes.push).not.toHaveBeenCalled();
+    });
+    it('should get organization from config if not passed', async () => {
+        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((_) => '.');
+        await (0, push_1.handlePush)({
+            argv: {
+                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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        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', async () => {
+        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((_) => '.');
+        await (0, push_1.handlePush)({
+            argv: {
+                '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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(api_1.ReuniteApi).toBeCalledWith({
+            domain: 'test-domain-from-env',
+            apiKey: 'test-api-key',
+            version: 'cli-version',
+            command: 'push',
+        });
+    });
+    it('should print error message', async () => {
+        const mockConfig = { apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.push.mockRestore();
+        remotes.push.mockRejectedValueOnce(new api_1.ReuniteApiError('Deprecated.', 412));
+        fsStatSyncSpy.mockReturnValueOnce({
+            isDirectory() {
+                return false;
+            },
+        });
+        pathResolveSpy.mockImplementationOnce((p) => p);
+        pathRelativeSpy.mockImplementationOnce((_, p) => p);
+        pathDirnameSpy.mockImplementation((_) => '.');
+        expect((0, push_1.handlePush)({
+            argv: {
+                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,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        })).rejects.toThrow('✗ File upload failed. Reason: Deprecated.');
+    });
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,51 @@
+"use strict";
+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', async () => {
+        const operation = jest
+            .fn()
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'done' });
+        const data = await (0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => result?.status === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+        });
+        expect(data).toEqual({ status: 'done' });
+    });
+    it('should throw error if condition not meet for desired timeout', async () => {
+        const operation = jest.fn().mockResolvedValue({ status: 'pending' });
+        await expect((0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => result?.status === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+        })).rejects.toThrow('Timeout exceeded.');
+    });
+    it('should call "onConditionNotMet" and "onRetry" callbacks', async () => {
+        const operation = jest
+            .fn()
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'done' });
+        const onConditionNotMet = jest.fn();
+        const onRetry = jest.fn();
+        const data = await (0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => 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

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

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePushStatus = handlePushStatus;
+const colors = require("colorette");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+const spinner_1 = require("../../utils/spinner");
+const utils_1 = require("../utils");
+const api_1 = require("../api");
+const js_utils_1 = require("../../utils/js-utils");
+const utils_2 = require("./utils");
+const RETRY_INTERVAL_MS = 5000; // 5 sec
+async function handlePushStatus({ argv, config, version, }) {
+    const startedAt = performance.now();
+    const spinner = new spinner_1.Spinner();
+    const { organization, project: projectId, pushId, wait } = argv;
+    const orgId = organization || config.organization;
+    if (!orgId) {
+        (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)();
+    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.ReuniteApi({ domain, apiKey, version, command: 'push-status' });
+        let pushResponse;
+        pushResponse = await (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 = await (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,
+            });
+        }
+        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 = {
+            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.
+        (0, utils_2.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, }) {
+    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 || 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, }) {
+    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':
+            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':
+            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

@@ -0,0 +1,28 @@
+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;
+export declare function handlePush({ argv, config, version, }: CommandArgs<PushOptions>): Promise<{
+    pushId: string;
+} | void>;