@redocly/cli 1.7.0 → 1.8.1

package/lib/cms/api/api-client.js

@@ -0,0 +1,148 @@
+"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.ReuniteApiClient = void 0;
+const fetch_with_timeout_1 = require("../../utils/fetch-with-timeout");
+const node_fetch_1 = require("node-fetch");
+const FormData = require("form-data");
+class RemotesApiClient {
+    constructor(domain, apiKey) {
+        this.domain = domain;
+        this.apiKey = apiKey;
+    }
+    getParsedResponse(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responseBody = yield response.json();
+            if (response.ok) {
+                return responseBody;
+            }
+            throw new Error(responseBody.title || response.statusText);
+        });
+    }
+    getDefaultBranch(organizationId, projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, node_fetch_1.default)(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/source`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            try {
+                const source = yield this.getParsedResponse(response);
+                return source.branchName;
+            }
+            catch (err) {
+                throw new Error(`Failed to fetch default branch: ${err.message || 'Unknown error'}`);
+            }
+        });
+    }
+    upsert(organizationId, projectId, remote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, node_fetch_1.default)(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    mountPath: remote.mountPath,
+                    mountBranchName: remote.mountBranchName,
+                    type: 'CICD',
+                    autoMerge: true,
+                }),
+            });
+            try {
+                return yield this.getParsedResponse(response);
+            }
+            catch (err) {
+                throw new Error(`Failed to upsert remote: ${err.message || 'Unknown error'}`);
+            }
+        });
+    }
+    push(organizationId, projectId, payload, files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData();
+            formData.append('remoteId', payload.remoteId);
+            formData.append('commit[message]', payload.commit.message);
+            formData.append('commit[author][name]', payload.commit.author.name);
+            formData.append('commit[author][email]', payload.commit.author.email);
+            formData.append('commit[branchName]', payload.commit.branchName);
+            payload.commit.url && formData.append('commit[url]', payload.commit.url);
+            payload.commit.namespace && formData.append('commit[namespaceId]', payload.commit.namespace);
+            payload.commit.sha && formData.append('commit[sha]', payload.commit.sha);
+            payload.commit.repository && formData.append('commit[repositoryId]', payload.commit.repository);
+            payload.commit.createdAt && formData.append('commit[createdAt]', payload.commit.createdAt);
+            for (const file of files) {
+                formData.append(`files[${file.path}]`, file.stream);
+            }
+            payload.isMainBranch && formData.append('isMainBranch', 'true');
+            const response = yield (0, node_fetch_1.default)(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: formData,
+            });
+            try {
+                return yield this.getParsedResponse(response);
+            }
+            catch (err) {
+                throw new Error(`Failed to push: ${err.message || 'Unknown error'}`);
+            }
+        });
+    }
+    getRemotesList(organizationId, projectId, mountPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, node_fetch_1.default)(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes?filter=mountPath:/${mountPath}/`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            try {
+                return yield this.getParsedResponse(response);
+            }
+            catch (err) {
+                throw new Error(`Failed to get remote list: ${err.message || 'Unknown error'}`);
+            }
+        });
+    }
+    getPush({ organizationId, projectId, pushId, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, fetch_with_timeout_1.default)(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes/${pushId}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response) {
+                throw new Error(`Failed to get push status: Time is up`);
+            }
+            try {
+                return yield this.getParsedResponse(response);
+            }
+            catch (err) {
+                throw new Error(`Failed to get push status: ${err.message || 'Unknown error'}`);
+            }
+        });
+    }
+}
+class ReuniteApiClient {
+    constructor(domain, apiKey) {
+        this.domain = domain;
+        this.apiKey = apiKey;
+        this.remotes = new RemotesApiClient(this.domain, this.apiKey);
+    }
+}
+exports.ReuniteApiClient = ReuniteApiClient;

package/lib/cms/api/api-keys.d.ts

@@ -0,0 +1 @@
+export declare function getApiKeys(domain: string): any;

package/lib/cms/api/api-keys.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiKeys = void 0;
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const utils_1 = require("@redocly/openapi-core/lib/utils");
+const redocly_1 = require("@redocly/openapi-core/lib/redocly");
+function readCredentialsFile(credentialsPath) {
+    return (0, fs_1.existsSync)(credentialsPath) ? JSON.parse((0, fs_1.readFileSync)(credentialsPath, 'utf-8')) : {};
+}
+function getApiKeys(domain) {
+    const apiKey = process.env.REDOCLY_AUTHORIZATION;
+    if (apiKey) {
+        return apiKey;
+    }
+    const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), redocly_1.TOKEN_FILENAME);
+    const credentials = readCredentialsFile(credentialsPath);
+    if ((0, utils_1.isNotEmptyObject)(credentials) && credentials[domain]) {
+        return credentials[domain];
+    }
+    throw new Error('No api key provided, please use environment variable REDOCLY_AUTHORIZATION.');
+}
+exports.getApiKeys = getApiKeys;

package/lib/cms/api/domains.d.ts

@@ -0,0 +1 @@
+export declare function getDomain(): string;

package/lib/cms/api/domains.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDomain = void 0;
+const DEFAULT_DOMAIN = 'https://app.cloud.redocly.com';
+function getDomain() {
+    const domain = process.env.REDOCLY_DOMAIN;
+    if (domain) {
+        return domain;
+    }
+    return DEFAULT_DOMAIN;
+}
+exports.getDomain = getDomain;

package/lib/cms/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api-client';
+export * from './domains';
+export * from './api-keys';

package/lib/cms/api/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-client"), exports);
+__exportStar(require("./domains"), exports);
+__exportStar(require("./api-keys"), exports);

package/lib/cms/api/types.d.ts

@@ -0,0 +1,91 @@
+export type ProjectSourceResponse = {
+    branchName: string;
+    contentPath: string;
+    isInternal: boolean;
+};
+export type UpsertRemoteResponse = {
+    id: string;
+    type: 'CICD';
+    mountPath: string;
+    mountBranchName: string;
+    organizationId: string;
+    projectId: string;
+};
+export type ListRemotesResponse = {
+    object: 'list';
+    page: {
+        endCursor: string;
+        startCursor: string;
+        haxNextPage: boolean;
+        hasPrevPage: boolean;
+        limit: number;
+        total: number;
+    };
+    items: Remote[];
+};
+export type Remote = {
+    mountPath: string;
+    type: string;
+    autoSync: boolean;
+    autoMerge: boolean;
+    createdAt: string;
+    updatedAt: string;
+    providerType: string;
+    namespaceId: string;
+    repositoryId: string;
+    projectId: string;
+    mountBranchName: string;
+    contentPath: string;
+    credentialId: string;
+    branchName: string;
+    contentType: string;
+    id: string;
+};
+export type PushResponse = {
+    id: string;
+    remoteId: string;
+    commit: {
+        message: string;
+        branchName: string;
+        sha: string | null;
+        url: string | null;
+        createdAt: string | null;
+        namespace: string | null;
+        repository: string | null;
+        author: {
+            name: string;
+            email: string;
+            image: string | null;
+        };
+    };
+    remote: {
+        commits: {
+            branchName: string;
+            sha: string;
+        }[];
+    };
+    hasChanges: boolean;
+    isOutdated: boolean;
+    isMainBranch: boolean;
+    status: PushStatusResponse;
+};
+type DeploymentStatusResponse = {
+    deploy: {
+        url: string | null;
+        status: DeploymentStatus;
+    };
+    scorecard: ScorecardItem[];
+};
+export type PushStatusResponse = {
+    preview: DeploymentStatusResponse;
+    production: DeploymentStatusResponse;
+};
+export type ScorecardItem = {
+    name: string;
+    status: PushStatusBase;
+    description: string;
+    url: string;
+};
+export type PushStatusBase = 'pending' | 'success' | 'running' | 'failed';
+export type DeploymentStatus = 'skipped' | PushStatusBase;
+export {};

package/lib/cms/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,164 @@
+"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 push_status_1 = require("../push-status");
+const miscellaneous_1 = require("../../../utils/miscellaneous");
+const remotes = {
+    getPush: jest.fn(),
+    getRemotesList: jest.fn(),
+};
+jest.mock('../../../utils/miscellaneous');
+jest.mock('colorette', () => ({
+    green: (str) => str,
+    yellow: (str) => str,
+    red: (str) => str,
+    gray: (str) => str,
+    magenta: (str) => str,
+    cyan: (str) => str,
+}));
+jest.mock('../../api', () => (Object.assign(Object.assign({}, jest.requireActual('../../api')), { ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
+        this.remotes = remotes;
+    }) })));
+describe('handlePushStatus()', () => {
+    const mockConfig = { apis: {} };
+    const pushResponseStub = {
+        hasChanges: true,
+        status: {
+            preview: {
+                scorecard: [],
+                deploy: {
+                    url: 'https://test-url',
+                    status: 'success',
+                },
+            },
+            production: {
+                scorecard: [],
+                deploy: {
+                    url: 'https://test-url',
+                    status: 'success',
+                },
+            },
+        },
+    };
+    beforeEach(() => {
+        jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should throw error if organization not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, push_status_1.handlePushStatus)({
+            domain: 'test-domain',
+            organization: '',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            'max-execution-time': 1000,
+        }, mockConfig);
+        expect(miscellaneous_1.exitWithError).toHaveBeenCalledWith("No organization provided, please use --organization option or specify the 'organization' field in the config file.");
+    }));
+    it('should return success push status for preview-build', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValueOnce(pushResponseStub);
+        yield (0, push_status_1.handlePushStatus)({
+            domain: 'test-domain',
+            organization: 'test-org',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            'max-execution-time': 1000,
+        }, mockConfig);
+        expect(process.stdout.write).toHaveBeenCalledTimes(1);
+        expect(process.stdout.write).toHaveBeenCalledWith('🚀 PREVIEW deployment succeeded.\nPreview URL: https://test-url\n');
+    }));
+    it('should return success push status for preview and production builds', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true }));
+        yield (0, push_status_1.handlePushStatus)({
+            domain: 'test-domain',
+            organization: 'test-org',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            'max-execution-time': 1000,
+        }, mockConfig);
+        expect(process.stdout.write).toHaveBeenCalledTimes(2);
+        expect(process.stdout.write).toHaveBeenCalledWith('🚀 PREVIEW deployment succeeded.\nPreview URL: https://test-url\n');
+        expect(process.stdout.write).toHaveBeenCalledWith('🚀 PRODUCTION deployment succeeded.\nPreview URL: https://test-url\n');
+    }));
+    it('should return failed push status for preview build', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValue({
+            isOutdated: false,
+            hasChanges: true,
+            status: {
+                preview: { deploy: { status: 'failed', url: 'https://test-url' }, scorecard: [] },
+            },
+        });
+        yield (0, push_status_1.handlePushStatus)({
+            domain: 'test-domain',
+            organization: 'test-org',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            'max-execution-time': 1000,
+        }, mockConfig);
+        expect(miscellaneous_1.exitWithError).toHaveBeenCalledWith('❌ PREVIEW deployment failed.\nPreview URL: https://test-url');
+    }));
+    it('should return success push status for preview build and print scorecards', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValue({
+            isOutdated: false,
+            hasChanges: true,
+            status: {
+                preview: {
+                    deploy: { status: 'success', url: 'https://test-url' },
+                    scorecard: [
+                        {
+                            name: 'test-name',
+                            status: 'success',
+                            description: 'test-description',
+                            url: 'test-url',
+                        },
+                    ],
+                },
+            },
+        });
+        yield (0, push_status_1.handlePushStatus)({
+            domain: 'test-domain',
+            organization: 'test-org',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            'max-execution-time': 1000,
+        }, mockConfig);
+        expect(process.stdout.write).toHaveBeenCalledTimes(4);
+        expect(process.stdout.write).toHaveBeenCalledWith('🚀 PREVIEW deployment succeeded.\nPreview URL: https://test-url\n');
+        expect(process.stdout.write).toHaveBeenCalledWith('\nScorecard:');
+        expect(process.stdout.write).toHaveBeenCalledWith('\n    Name: test-name\n    Status: success\n    URL: test-url\n    Description: test-description\n');
+        expect(process.stdout.write).toHaveBeenCalledWith('\n');
+    }));
+    it('should display message if there is no changes', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValueOnce({
+            isOutdated: false,
+            hasChanges: false,
+            status: {
+                preview: { deploy: { status: 'skipped', url: 'https://test-url' }, scorecard: [] },
+            },
+        });
+        yield (0, push_status_1.handlePushStatus)({
+            domain: 'test-domain',
+            organization: 'test-org',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            wait: true,
+            'max-execution-time': 1000,
+        }, mockConfig);
+        expect(process.stderr.write).toHaveBeenCalledWith('Files not uploaded. Reason: no changes.\n');
+    }));
+});

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

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