@redocly/cli 0.0.0-snapshot.1737627998 → 0.0.0-snapshot.1739895544

package/README.md

@@ -28,7 +28,7 @@ Then you can use it as `redocly [command] [options]`, for example:
 redocly lint path-to-root-file.yaml
 ```
 
-The minimum required versions of Node.js and NPM are 14.19.0 and 7.0.0 respectively.
+The minimum required versions of Node.js and NPM are 18.17.0 and 10.8.2 respectively.
 
 ### Docker
 

package/lib/__tests__/commands/push-region.test.js

@@ -2,28 +2,61 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const openapi_core_1 = require("@redocly/openapi-core");
 const push_1 = require("../../commands/push");
-const login_1 = require("../../commands/login");
+const auth_1 = require("../../commands/auth");
 const config_1 = require("../fixtures/config");
-jest.mock('fs');
-jest.mock('node-fetch', () => ({
-    default: jest.fn(() => ({
-        ok: true,
-        json: jest.fn().mockResolvedValue({}),
-    })),
+const node_stream_1 = require("node:stream");
+// Mock fs operations
+jest.mock('fs', () => ({
+    ...jest.requireActual('fs'),
+    createReadStream: () => {
+        const readable = new node_stream_1.Readable();
+        readable.push('test data');
+        readable.push(null);
+        return readable;
+    },
+    statSync: () => ({ size: 9 }),
+    readFileSync: () => Buffer.from('test data'),
+    existsSync: () => false,
+    readdirSync: () => [],
 }));
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+// Mock OpenAPI core
 jest.mock('@redocly/openapi-core');
-jest.mock('../../commands/login');
+jest.mock('../../commands/auth');
 jest.mock('../../utils/miscellaneous');
-openapi_core_1.getMergedConfig.mockImplementation((config) => config);
-const mockPromptClientToken = login_1.promptClientToken;
+const mockPromptClientToken = auth_1.promptClientToken;
 describe('push-with-region', () => {
     const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
     redoclyClient.isAuthorizedWithRedoclyByRegion = jest.fn().mockResolvedValue(false);
+    const originalFetch = fetch;
     beforeAll(() => {
+        // Mock global fetch
+        global.fetch = jest.fn(() => Promise.resolve({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({}),
+            headers: new Headers(),
+            statusText: 'OK',
+            redirected: false,
+            type: 'default',
+            url: '',
+            clone: () => ({}),
+            body: new ReadableStream(),
+            bodyUsed: false,
+            arrayBuffer: async () => new ArrayBuffer(0),
+            blob: async () => new Blob(),
+            formData: async () => new FormData(),
+            text: async () => '',
+        }));
+    });
+    afterAll(() => {
+        global.fetch = originalFetch;
+    });
+    beforeEach(() => {
         jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
     });
     it('should call login with default domain when region is US', async () => {
-        redoclyClient.domain = 'redoc.ly';
+        redoclyClient.domain = 'redocly.com';
         await (0, push_1.handlePush)({
             argv: {
                 upsert: true,
@@ -39,6 +72,8 @@ describe('push-with-region', () => {
     });
     it('should call login with EU domain when region is EU', async () => {
         redoclyClient.domain = 'eu.redocly.com';
+        // Update config for EU region
+        const euConfig = { ...config_1.ConfigFixture, region: 'eu' };
         await (0, push_1.handlePush)({
             argv: {
                 upsert: true,
@@ -46,7 +81,7 @@ describe('push-with-region', () => {
                 destination: '@org/my-api@1.0.0',
                 branchName: 'test',
             },
-            config: config_1.ConfigFixture,
+            config: euConfig,
             version: 'cli-version',
         });
         expect(mockPromptClientToken).toBeCalledTimes(1);

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

@@ -6,21 +6,54 @@ const miscellaneous_1 = require("../../utils/miscellaneous");
 const push_1 = require("../../commands/push");
 const config_1 = require("../fixtures/config");
 const colorette_1 = require("colorette");
-jest.mock('fs');
-jest.mock('node-fetch', () => ({
-    default: jest.fn(() => ({
-        ok: true,
-        json: jest.fn().mockResolvedValue({}),
-    })),
+const node_stream_1 = require("node:stream");
+// Mock fs operations
+jest.mock('fs', () => ({
+    ...jest.requireActual('fs'),
+    createReadStream: jest.fn(() => {
+        const readable = new node_stream_1.Readable();
+        readable.push('test data');
+        readable.push(null);
+        return readable;
+    }),
+    statSync: jest.fn(() => ({ isDirectory: () => false, size: 10 })),
+    readFileSync: jest.fn(() => Buffer.from('test data')),
+    existsSync: jest.fn(() => false),
+    readdirSync: jest.fn(() => []),
 }));
 jest.mock('@redocly/openapi-core');
 jest.mock('../../utils/miscellaneous');
+// Mock fetch
+const mockFetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve({}),
+    headers: new Headers(),
+    statusText: 'OK',
+    redirected: false,
+    type: 'default',
+    url: '',
+    clone: () => ({}),
+    body: null,
+    bodyUsed: false,
+    arrayBuffer: async () => new ArrayBuffer(0),
+    blob: async () => new Blob(),
+    formData: async () => new FormData(),
+    text: async () => '',
+}));
+const originalFetch = global.fetch;
 openapi_core_1.getMergedConfig.mockImplementation((config) => config);
 describe('push', () => {
     const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    beforeAll(() => {
+        global.fetch = mockFetch;
+    });
     beforeEach(() => {
         jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
     });
+    afterAll(() => {
+        global.fetch = originalFetch;
+    });
     it('pushes definition', async () => {
         await (0, push_1.handlePush)({
             argv: {

package/lib/__tests__/fetch-with-timeout.test.js

@@ -2,11 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const abort_controller_1 = require("abort-controller");
 const fetch_with_timeout_1 = require("../utils/fetch-with-timeout");
-const node_fetch_1 = require("node-fetch");
 const openapi_core_1 = require("@redocly/openapi-core");
 const https_proxy_agent_1 = require("https-proxy-agent");
-jest.mock('node-fetch');
 jest.mock('@redocly/openapi-core');
+const signalInstance = new abort_controller_1.default().signal;
+const mockFetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve({}),
+    headers: new Headers(),
+    statusText: 'OK',
+    redirected: false,
+    type: 'default',
+    url: '',
+    clone: () => ({}),
+    body: null,
+    bodyUsed: false,
+    arrayBuffer: async () => new ArrayBuffer(0),
+    blob: async () => new Blob(),
+    formData: async () => new FormData(),
+    text: async () => '',
+    signal: signalInstance,
+    dispatcher: undefined,
+}));
+const originalFetch = global.fetch;
+global.fetch = mockFetch;
 describe('fetchWithTimeout', () => {
     beforeAll(() => {
         // @ts-ignore
@@ -16,29 +36,29 @@ describe('fetchWithTimeout', () => {
     beforeEach(() => {
         openapi_core_1.getProxyAgent.mockReturnValueOnce(undefined);
     });
-    afterEach(() => {
-        jest.clearAllMocks();
+    afterAll(() => {
+        global.fetch = originalFetch;
     });
-    it('should call node-fetch with signal', async () => {
+    it('should call fetch with signal', async () => {
         await (0, fetch_with_timeout_1.default)('url', { timeout: 1000 });
         expect(global.setTimeout).toHaveBeenCalledTimes(1);
-        expect(node_fetch_1.default).toHaveBeenCalledWith('url', {
-            signal: new abort_controller_1.default().signal,
-            agent: undefined,
-        });
+        expect(global.fetch).toHaveBeenCalledWith('url', expect.objectContaining({
+            signal: expect.any(AbortSignal),
+            dispatcher: undefined,
+        }));
         expect(global.clearTimeout).toHaveBeenCalledTimes(1);
     });
-    it('should call node-fetch with proxy agent', async () => {
+    it('should call fetch with proxy agent', async () => {
         openapi_core_1.getProxyAgent.mockRestore();
         const proxyAgent = new https_proxy_agent_1.HttpsProxyAgent('http://localhost');
         openapi_core_1.getProxyAgent.mockReturnValueOnce(proxyAgent);
         await (0, fetch_with_timeout_1.default)('url');
-        expect(node_fetch_1.default).toHaveBeenCalledWith('url', { agent: proxyAgent });
+        expect(global.fetch).toHaveBeenCalledWith('url', { dispatcher: proxyAgent });
     });
-    it('should call node-fetch without signal when timeout is not passed', async () => {
+    it('should call fetch without signal when timeout is not passed', async () => {
         await (0, fetch_with_timeout_1.default)('url');
         expect(global.setTimeout).not.toHaveBeenCalled();
-        expect(node_fetch_1.default).toHaveBeenCalledWith('url', { agent: undefined });
+        expect(global.fetch).toHaveBeenCalledWith('url', { agent: undefined });
         expect(global.clearTimeout).not.toHaveBeenCalled();
     });
 });

package/lib/__tests__/utils.test.js

@@ -409,6 +409,7 @@ describe('checkIfRulesetExist', () => {
             async2: {},
             async3: {},
             arazzo1: {},
+            overlay1: {},
         };
         expect(() => (0, miscellaneous_1.checkIfRulesetExist)(rules)).toThrowError('⚠️ No rules were configured. Learn how to configure rules: https://redocly.com/docs/cli/rules/');
     });

package/lib/__tests__/wrapper.test.js

@@ -6,11 +6,19 @@ const wrapper_1 = require("../wrapper");
 const lint_1 = require("../commands/lint");
 const push_1 = require("../commands/push");
 const openapi_core_1 = require("@redocly/openapi-core");
-jest.mock('node-fetch');
+const mockFetch = jest.fn();
+const originalFetch = global.fetch;
 jest.mock('../utils/miscellaneous', () => ({
     sendTelemetry: jest.fn(),
     loadConfigAndHandleErrors: jest.fn(),
 }));
+beforeAll(() => {
+    global.fetch = mockFetch;
+});
+afterAll(() => {
+    jest.resetAllMocks();
+    global.fetch = originalFetch;
+});
 jest.mock('../commands/lint', () => ({
     handleLint: jest.fn().mockImplementation(({ collectSpecData }) => {
         collectSpecData({ openapi: '3.1.0' });

package/lib/auth/__tests__/device-flow.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const device_flow_1 = require("../device-flow");
+jest.mock('child_process');
+describe('RedoclyOAuthDeviceFlow', () => {
+    const mockBaseUrl = 'https://test.redocly.com';
+    const mockClientName = 'test-client';
+    const mockVersion = '1.0.0';
+    let flow;
+    beforeEach(() => {
+        flow = new device_flow_1.RedoclyOAuthDeviceFlow(mockBaseUrl, mockClientName, mockVersion);
+        jest.resetAllMocks();
+    });
+    describe('verifyToken', () => {
+        it('returns true for valid token', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve({ user: { id: '123' } }),
+            });
+            const result = await flow.verifyToken('valid-token');
+            expect(result).toBe(true);
+        });
+        it('returns false for invalid token', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockRejectedValue(new Error('Invalid token'));
+            const result = await flow.verifyToken('invalid-token');
+            expect(result).toBe(false);
+        });
+    });
+    describe('verifyApiKey', () => {
+        it('returns true for valid API key', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve({ success: true }),
+            });
+            const result = await flow.verifyApiKey('valid-key');
+            expect(result).toBe(true);
+        });
+        it('returns false for invalid API key', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockRejectedValue(new Error('Invalid API key'));
+            const result = await flow.verifyApiKey('invalid-key');
+            expect(result).toBe(false);
+        });
+    });
+    describe('refreshToken', () => {
+        it('successfully refreshes token', async () => {
+            const mockResponse = {
+                access_token: 'new-token',
+                refresh_token: 'new-refresh',
+                expires_in: 3600,
+            };
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve(mockResponse),
+            });
+            const result = await flow.refreshToken('old-refresh-token');
+            expect(result).toEqual(mockResponse);
+        });
+        it('throws error when refresh fails', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve({}),
+            });
+            await expect(flow.refreshToken('invalid-refresh')).rejects.toThrow('Failed to refresh token');
+        });
+    });
+});

package/lib/auth/__tests__/oauth-client.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const oauth_client_1 = require("../oauth-client");
+const device_flow_1 = require("../device-flow");
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+jest.mock('node:fs');
+jest.mock('node:os');
+jest.mock('../device-flow');
+describe('RedoclyOAuthClient', () => {
+    const mockClientName = 'test-client';
+    const mockVersion = '1.0.0';
+    const mockBaseUrl = 'https://test.redocly.com';
+    const mockHomeDir = '/mock/home/dir';
+    const mockRedoclyDir = path.join(mockHomeDir, '.redocly');
+    let client;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        os.homedir.mockReturnValue(mockHomeDir);
+        process.env.HOME = mockHomeDir;
+        client = new oauth_client_1.RedoclyOAuthClient(mockClientName, mockVersion);
+    });
+    describe('login', () => {
+        it('successfully logs in and saves token', async () => {
+            const mockToken = { access_token: 'test-token' };
+            const mockDeviceFlow = {
+                run: jest.fn().mockResolvedValue(mockToken),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            await client.login(mockBaseUrl);
+            expect(mockDeviceFlow.run).toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+        });
+        it('throws error when login fails', async () => {
+            const mockDeviceFlow = {
+                run: jest.fn().mockResolvedValue(null),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            await expect(client.login(mockBaseUrl)).rejects.toThrow('Failed to login');
+        });
+    });
+    describe('logout', () => {
+        it('removes token file if it exists', async () => {
+            fs.existsSync.mockReturnValue(true);
+            await client.logout();
+            expect(fs.rmSync).toHaveBeenCalledWith(path.join(mockRedoclyDir, 'auth.json'));
+        });
+        it('silently fails if token file does not exist', async () => {
+            fs.existsSync.mockReturnValue(false);
+            await expect(client.logout()).resolves.not.toThrow();
+            expect(fs.rmSync).not.toHaveBeenCalled();
+        });
+    });
+    describe('isAuthorized', () => {
+        it('verifies API key if provided', async () => {
+            const mockDeviceFlow = {
+                verifyApiKey: jest.fn().mockResolvedValue(true),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            const result = await client.isAuthorized(mockBaseUrl, 'test-api-key');
+            expect(result).toBe(true);
+            expect(mockDeviceFlow.verifyApiKey).toHaveBeenCalledWith('test-api-key');
+        });
+        it('verifies access token if no API key provided', async () => {
+            const mockToken = { access_token: 'test-token' };
+            const mockDeviceFlow = {
+                verifyToken: jest.fn().mockResolvedValue(true),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            fs.readFileSync.mockReturnValue(client['cipher'].update(JSON.stringify(mockToken), 'utf8', 'hex') +
+                client['cipher'].final('hex'));
+            const result = await client.isAuthorized(mockBaseUrl);
+            expect(result).toBe(true);
+            expect(mockDeviceFlow.verifyToken).toHaveBeenCalledWith('test-token');
+        });
+        it('returns false if token refresh fails', async () => {
+            const mockToken = {
+                access_token: 'old-token',
+                refresh_token: 'refresh-token',
+            };
+            const mockDeviceFlow = {
+                verifyToken: jest.fn().mockResolvedValue(false),
+                refreshToken: jest.fn().mockRejectedValue(new Error('Refresh failed')),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            fs.readFileSync.mockReturnValue(client['cipher'].update(JSON.stringify(mockToken), 'utf8', 'hex') +
+                client['cipher'].final('hex'));
+            const result = await client.isAuthorized(mockBaseUrl);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/auth/device-flow.d.ts

@@ -0,0 +1,26 @@
+export type AuthToken = {
+    access_token: string;
+    refresh_token?: string;
+    token_type?: string;
+    expires_in?: number;
+};
+export declare class RedoclyOAuthDeviceFlow {
+    private baseUrl;
+    private clientName;
+    private version;
+    private apiClient;
+    constructor(baseUrl: string, clientName: string, version: string);
+    run(): Promise<AuthToken>;
+    private openBrowser;
+    verifyToken(accessToken: string): Promise<boolean>;
+    verifyApiKey(apiKey: string): Promise<boolean>;
+    refreshToken(refreshToken: string): Promise<{
+        access_token: any;
+        refresh_token: any;
+        expires_in: any;
+    }>;
+    private pollingAccessToken;
+    private getAccessToken;
+    private getDeviceCode;
+    private sendRequest;
+}

package/lib/auth/device-flow.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedoclyOAuthDeviceFlow = void 0;
+const colorette_1 = require("colorette");
+const childProcess = require("child_process");
+const api_client_1 = require("../reunite/api/api-client");
+class RedoclyOAuthDeviceFlow {
+    constructor(baseUrl, clientName, version) {
+        this.baseUrl = baseUrl;
+        this.clientName = clientName;
+        this.version = version;
+        this.apiClient = new api_client_1.ReuniteApiClient(this.version, 'login');
+    }
+    async run() {
+        const code = await this.getDeviceCode();
+        process.stdout.write('Attempting to automatically open the SSO authorization page in your default browser.\n');
+        process.stdout.write('If the browser does not open or you wish to use a different device to authorize this request, open the following URL:\n\n');
+        process.stdout.write((0, colorette_1.blue)(code.verificationUri));
+        process.stdout.write(`\n\n`);
+        process.stdout.write(`Then enter the code:\n\n`);
+        process.stdout.write((0, colorette_1.blue)(code.userCode));
+        process.stdout.write(`\n\n`);
+        this.openBrowser(code.verificationUriComplete);
+        const accessToken = await this.pollingAccessToken(code.deviceCode, code.interval, code.expiresIn);
+        process.stdout.write((0, colorette_1.green)('✅ Logged in\n\n'));
+        return accessToken;
+    }
+    openBrowser(url) {
+        try {
+            const cmd = process.platform === 'win32'
+                ? `start ${url}`
+                : process.platform === 'darwin'
+                    ? `open ${url}`
+                    : `xdg-open ${url}`;
+            childProcess.execSync(cmd);
+        }
+        catch {
+            // silently fail if browser cannot be opened
+        }
+    }
+    async verifyToken(accessToken) {
+        try {
+            const response = await this.sendRequest('/session', 'GET', undefined, {
+                Cookie: `accessToken=${accessToken};`,
+            });
+            return !!response.user;
+        }
+        catch {
+            return false;
+        }
+    }
+    async verifyApiKey(apiKey) {
+        try {
+            const response = await this.sendRequest('/api-keys-verify', 'POST', {
+                apiKey,
+            });
+            return !!response.success;
+        }
+        catch {
+            return false;
+        }
+    }
+    async refreshToken(refreshToken) {
+        const response = await this.sendRequest(`/device-rotate-token`, 'POST', {
+            grant_type: 'refresh_token',
+            client_name: this.clientName,
+            refresh_token: refreshToken,
+        });
+        if (!response.access_token) {
+            throw new Error('Failed to refresh token');
+        }
+        return {
+            access_token: response.access_token,
+            refresh_token: response.refresh_token,
+            expires_in: response.expires_in,
+        };
+    }
+    async pollingAccessToken(deviceCode, interval, expiresIn) {
+        return new Promise((resolve, reject) => {
+            const intervalId = setInterval(async () => {
+                const response = await this.getAccessToken(deviceCode);
+                if (response.access_token) {
+                    clearInterval(intervalId);
+                    clearTimeout(timeoutId);
+                    resolve(response);
+                }
+                if (response.error && response.error !== 'authorization_pending') {
+                    clearInterval(intervalId);
+                    clearTimeout(timeoutId);
+                    reject(response.error_description);
+                }
+            }, interval * 1000);
+            const timeoutId = setTimeout(async () => {
+                clearInterval(intervalId);
+                clearTimeout(timeoutId);
+                reject('Authorization has expired. Please try again.');
+            }, expiresIn * 1000);
+        });
+    }
+    async getAccessToken(deviceCode) {
+        return await this.sendRequest('/device-token', 'POST', {
+            client_name: this.clientName,
+            device_code: deviceCode,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        });
+    }
+    async getDeviceCode() {
+        const { device_code: deviceCode, user_code: userCode, verification_uri: verificationUri, verification_uri_complete: verificationUriComplete, interval = 10, expires_in: expiresIn = 300, } = await this.sendRequest('/device-authorize', 'POST', {
+            client_name: this.clientName,
+        });
+        return {
+            deviceCode,
+            userCode,
+            verificationUri,
+            verificationUriComplete,
+            interval,
+            expiresIn,
+        };
+    }
+    async sendRequest(url, method = 'GET', body = undefined, headers = {}) {
+        url = `${this.baseUrl}${url}`;
+        const response = await this.apiClient.request(url, {
+            body: body ? JSON.stringify(body) : body,
+            method,
+            headers: { 'Content-Type': 'application/json', ...headers },
+        });
+        if (response.status === 204) {
+            return { success: true };
+        }
+        return await response.json();
+    }
+}
+exports.RedoclyOAuthDeviceFlow = RedoclyOAuthDeviceFlow;

package/lib/auth/oauth-client.d.ts

@@ -0,0 +1,14 @@
+export declare class RedoclyOAuthClient {
+    private clientName;
+    private version;
+    private dir;
+    private cipher;
+    private decipher;
+    constructor(clientName: string, version: string);
+    login(baseUrl: string): Promise<void>;
+    logout(): Promise<void>;
+    isAuthorized(baseUrl: string, apiKey?: string): Promise<boolean>;
+    private saveToken;
+    private readToken;
+    private removeToken;
+}