@redocly/cli 0.0.0-snapshot.1744362365 → 0.0.0-snapshot.1744801622

package/README.md

@@ -16,7 +16,7 @@ Supports OpenAPI 3.1, 3.0 and OpenAPI 2.0 (legacy Swagger), AsyncAPI 3.0 and 2.6
 ### Node
 
 ```sh
-npx @redocly/cli@latest lint path-to-root-file.yaml
+npx @redocly/cli@v1 lint path-to-root-file.yaml
 ```
 
 Alternatively, install it globally with `npm`:

package/bin/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import '../lib/index.js';
+require('../lib/index');

package/lib/__mocks__/@redocly/openapi-core.d.ts

@@ -0,0 +1,99 @@
+import type { Document } from '@redocly/openapi-core';
+export declare const __redoclyClient: {
+    isAuthorizedWithRedocly: jest.Mock<any, any>;
+    isAuthorizedWithRedoclyByRegion: jest.Mock<any, any>;
+    login: jest.Mock<any, any>;
+    registryApi: {
+        setAccessTokens: jest.Mock<any, any>;
+        authStatus: jest.Mock<any, any>;
+        prepareFileUpload: jest.Mock<any, any>;
+        pushApi: jest.Mock<any, any>;
+    };
+};
+export declare const RedoclyClient: jest.Mock<{
+    isAuthorizedWithRedocly: jest.Mock<any, any>;
+    isAuthorizedWithRedoclyByRegion: jest.Mock<any, any>;
+    login: jest.Mock<any, any>;
+    registryApi: {
+        setAccessTokens: jest.Mock<any, any>;
+        authStatus: jest.Mock<any, any>;
+        prepareFileUpload: jest.Mock<any, any>;
+        pushApi: jest.Mock<any, any>;
+    };
+}, []>;
+export declare const loadConfig: jest.Mock<{
+    configFile: null;
+    styleguide: {
+        addIgnore: jest.Mock<any, any>;
+        skipRules: jest.Mock<any, any>;
+        skipPreprocessors: jest.Mock<any, any>;
+        saveIgnore: jest.Mock<any, any>;
+        skipDecorators: jest.Mock<any, any>;
+        ignore: null;
+        decorators: {
+            oas2: {};
+            oas3_0: {};
+            oas3_1: {};
+        };
+        preprocessors: {
+            oas2: {};
+            oas3_0: {};
+            oas3_1: {};
+        };
+    };
+}, []>;
+export declare const getMergedConfig: jest.Mock<any, any>;
+export declare const getProxyAgent: jest.Mock<any, any>;
+export declare const lint: jest.Mock<any, any>;
+export declare const bundle: jest.Mock<{
+    bundle: {
+        parsed: null;
+    };
+    problems: null;
+}, []>;
+export declare const getTotals: jest.Mock<{
+    errors: number;
+}, []>;
+export declare const formatProblems: jest.Mock<any, any>;
+export declare const slash: jest.Mock<any, any>;
+export declare const findConfig: jest.Mock<any, any>;
+export declare const doesYamlFileExist: jest.Mock<any, any>;
+export declare const bundleDocument: jest.Mock<Promise<{
+    problems: {};
+}>, []>;
+export declare const detectSpec: jest.Mock<any, any>;
+export declare const isAbsoluteUrl: jest.Mock<any, any>;
+export declare const stringifyYaml: jest.Mock<any, [data: any]>;
+export declare class BaseResolver {
+    cache: Map<string, Promise<Document | ResolveError>>;
+    getFiles: jest.Mock<any, any>;
+    resolveExternalRef: jest.Mock<any, any>;
+    loadExternalRef: typeof jest.fn;
+    parseDocument: jest.Mock<any, any>;
+    resolveDocument: jest.Mock<any, any>;
+}
+export declare class ResolveError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}
+export declare class YamlParseError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}
+export declare enum SpecVersion {
+    OAS2 = "oas2",
+    OAS3_0 = "oas3_0",
+    OAS3_1 = "oas3_1",
+    Async2 = "async2",
+    Async3 = "async3"
+}
+export declare enum Oas3Operations {
+    get = "get",
+    put = "put",
+    post = "post",
+    delete = "delete",
+    options = "options",
+    head = "head",
+    patch = "patch",
+    trace = "trace"
+}

package/lib/__mocks__/@redocly/openapi-core.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Oas3Operations = exports.SpecVersion = exports.YamlParseError = exports.ResolveError = exports.BaseResolver = exports.stringifyYaml = exports.isAbsoluteUrl = exports.detectSpec = exports.bundleDocument = exports.doesYamlFileExist = exports.findConfig = exports.slash = exports.formatProblems = exports.getTotals = exports.bundle = exports.lint = exports.getProxyAgent = exports.getMergedConfig = exports.loadConfig = exports.RedoclyClient = exports.__redoclyClient = void 0;
+const config_1 = require("./../../__tests__/fixtures/config");
+const documents_1 = require("../documents");
+exports.__redoclyClient = {
+    isAuthorizedWithRedocly: jest.fn().mockResolvedValue(true),
+    isAuthorizedWithRedoclyByRegion: jest.fn().mockResolvedValue(true),
+    login: jest.fn(),
+    registryApi: {
+        setAccessTokens: jest.fn(),
+        authStatus: jest.fn(),
+        prepareFileUpload: jest.fn().mockResolvedValue({
+            signedUploadUrl: 'signedUploadUrl',
+            filePath: 'filePath',
+        }),
+        pushApi: jest.fn(),
+    },
+};
+exports.RedoclyClient = jest.fn(() => exports.__redoclyClient);
+exports.loadConfig = jest.fn(() => config_1.ConfigFixture);
+exports.getMergedConfig = jest.fn();
+exports.getProxyAgent = jest.fn();
+exports.lint = jest.fn();
+exports.bundle = jest.fn(() => ({ bundle: { parsed: null }, problems: null }));
+exports.getTotals = jest.fn(() => ({ errors: 0 }));
+exports.formatProblems = jest.fn();
+exports.slash = jest.fn();
+exports.findConfig = jest.fn();
+exports.doesYamlFileExist = jest.fn();
+exports.bundleDocument = jest.fn(() => Promise.resolve({ problems: {} }));
+exports.detectSpec = jest.fn();
+exports.isAbsoluteUrl = jest.fn();
+exports.stringifyYaml = jest.fn((data) => data);
+class BaseResolver {
+    constructor() {
+        this.cache = new Map();
+        this.getFiles = jest.fn();
+        this.resolveExternalRef = jest.fn();
+        this.loadExternalRef = jest.fn;
+        this.parseDocument = jest.fn();
+        this.resolveDocument = jest
+            .fn()
+            .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.firstDocument }))
+            .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.secondDocument }))
+            .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.thirdDocument }));
+    }
+}
+exports.BaseResolver = BaseResolver;
+class ResolveError extends Error {
+    constructor(originalError) {
+        super(originalError.message);
+        this.originalError = originalError;
+        Object.setPrototypeOf(this, ResolveError.prototype);
+    }
+}
+exports.ResolveError = ResolveError;
+class YamlParseError extends Error {
+    constructor(originalError) {
+        super(originalError.message);
+        this.originalError = originalError;
+        Object.setPrototypeOf(this, YamlParseError.prototype);
+    }
+}
+exports.YamlParseError = YamlParseError;
+var SpecVersion;
+(function (SpecVersion) {
+    SpecVersion["OAS2"] = "oas2";
+    SpecVersion["OAS3_0"] = "oas3_0";
+    SpecVersion["OAS3_1"] = "oas3_1";
+    SpecVersion["Async2"] = "async2";
+    SpecVersion["Async3"] = "async3";
+})(SpecVersion || (exports.SpecVersion = SpecVersion = {}));
+var Oas3Operations;
+(function (Oas3Operations) {
+    Oas3Operations["get"] = "get";
+    Oas3Operations["put"] = "put";
+    Oas3Operations["post"] = "post";
+    Oas3Operations["delete"] = "delete";
+    Oas3Operations["options"] = "options";
+    Oas3Operations["head"] = "head";
+    Oas3Operations["patch"] = "patch";
+    Oas3Operations["trace"] = "trace";
+})(Oas3Operations || (exports.Oas3Operations = Oas3Operations = {}));

package/lib/__mocks__/documents.d.ts

@@ -0,0 +1,150 @@
+export declare const firstDocument: {
+    openapi: string;
+    servers: {
+        url: string;
+    }[];
+    info: {
+        description: string;
+        version: string;
+        title: string;
+        termsOfService: string;
+        license: {
+            name: string;
+            url: string;
+        };
+    };
+    paths: {
+        '/GETUser/{userId}': {
+            summary: string;
+            description: string;
+            servers: ({
+                url: string;
+                description?: undefined;
+            } | {
+                url: string;
+                description: string;
+            })[];
+            get: {
+                tags: string[];
+                summary: string;
+                description: string;
+                operationId: string;
+                servers: {
+                    url: string;
+                }[];
+            };
+            parameters: {
+                name: string;
+                in: string;
+                schema: {
+                    description: string;
+                };
+            }[];
+        };
+    };
+    components: {};
+};
+export declare const secondDocument: {
+    openapi: string;
+    servers: {
+        url: string;
+    }[];
+    info: {
+        description: string;
+        version: string;
+        title: string;
+        termsOfService: string;
+        license: {
+            name: string;
+            url: string;
+        };
+    };
+    post: {
+        '/GETUser/{userId}': {
+            summary: string;
+            description: string;
+            servers: ({
+                url: string;
+                description?: undefined;
+            } | {
+                url: string;
+                description: string;
+            })[];
+            get: {
+                tags: string[];
+                summary: string;
+                description: string;
+                operationId: string;
+                servers: {
+                    url: string;
+                }[];
+            };
+            parameters: {
+                name: string;
+                in: string;
+                schema: {
+                    description: string;
+                };
+            }[];
+        };
+    };
+    components: {};
+};
+export declare const thirdDocument: {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    paths: {};
+    components: {
+        schemas: {
+            SchemaWithNull: {
+                type: string;
+                default: null;
+                nullable: boolean;
+            };
+            SchemaWithRef: {
+                type: string;
+                properties: {
+                    schemaType: {
+                        type: string;
+                        enum: string[];
+                    };
+                    foo: {
+                        $ref: string;
+                    };
+                };
+            };
+            SchemaWithDiscriminator: {
+                discriminator: {
+                    propertyName: string;
+                    mapping: {
+                        foo: string;
+                        bar: string;
+                    };
+                };
+                oneOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    properties?: undefined;
+                } | {
+                    type: string;
+                    properties: {
+                        schemaType: {
+                            type: string;
+                            enum: string[];
+                        };
+                        bar: {
+                            type: string;
+                        };
+                    };
+                    $ref?: undefined;
+                })[];
+            };
+        };
+    };
+};

package/lib/__mocks__/documents.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thirdDocument = exports.secondDocument = exports.firstDocument = void 0;
+exports.firstDocument = {
+    openapi: '3.0.0',
+    servers: [{ url: 'http://localhost:8080' }],
+    info: {
+        description: 'example test',
+        version: '1.0.0',
+        title: 'First API',
+        termsOfService: 'http://swagger.io/terms/',
+        license: {
+            name: 'Apache 2.0',
+            url: 'http://www.apache.org/licenses/LICENSE-2.0.html',
+        },
+    },
+    paths: {
+        '/GETUser/{userId}': {
+            summary: 'get user by id',
+            description: 'user info',
+            servers: [{ url: '/user' }, { url: '/pet', description: 'pet server' }],
+            get: {
+                tags: ['pet'],
+                summary: 'Find pet by ID',
+                description: 'Returns a single pet',
+                operationId: 'getPetById',
+                servers: [{ url: '/pet' }],
+            },
+            parameters: [{ name: 'param1', in: 'header', schema: { description: 'string' } }],
+        },
+    },
+    components: {},
+};
+exports.secondDocument = {
+    openapi: '3.0.0',
+    servers: [{ url: 'http://localhost:8080' }],
+    info: {
+        description: 'example test',
+        version: '1.0.0',
+        title: 'Second API',
+        termsOfService: 'http://swagger.io/terms/',
+        license: {
+            name: 'Apache 2.0',
+            url: 'http://www.apache.org/licenses/LICENSE-2.0.html',
+        },
+    },
+    post: {
+        '/GETUser/{userId}': {
+            summary: 'get user',
+            description: 'user information',
+            servers: [{ url: '/user' }, { url: '/pet', description: '' }],
+            get: {
+                tags: ['pet'],
+                summary: 'Find pet by ID',
+                description: 'Returns a single pet',
+                operationId: 'getPetById',
+                servers: [{ url: '/pet' }],
+            },
+            parameters: [{ name: 'param1', in: 'header', schema: { description: 'string' } }],
+        },
+    },
+    components: {},
+};
+exports.thirdDocument = {
+    openapi: '3.0.0',
+    info: {
+        title: 'Third API',
+        version: '1.0',
+    },
+    servers: [
+        {
+            url: 'https://api.server.test/v1',
+        },
+    ],
+    paths: {},
+    components: {
+        schemas: {
+            SchemaWithNull: {
+                type: 'string',
+                default: null,
+                nullable: true,
+            },
+            SchemaWithRef: {
+                type: 'object',
+                properties: {
+                    schemaType: {
+                        type: 'string',
+                        enum: ['foo'],
+                    },
+                    foo: {
+                        $ref: '#/components/schemas/SchemaWithNull',
+                    },
+                },
+            },
+            SchemaWithDiscriminator: {
+                discriminator: {
+                    propertyName: 'schemaType',
+                    mapping: {
+                        foo: '#/components/schemas/SchemaWithRef',
+                        bar: '#/components/schemas/SchemaWithNull',
+                    },
+                },
+                oneOf: [
+                    {
+                        $ref: '#/components/schemas/SchemaWithRef',
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            schemaType: {
+                                type: 'string',
+                                enum: ['bar'],
+                            },
+                            bar: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};

package/lib/__mocks__/fs.d.ts

@@ -0,0 +1,8 @@
+export declare const existsSync: jest.Mock<any, any>;
+export declare const readFileSync: jest.Mock<string, []>;
+export declare const statSync: jest.Mock<{
+    size: number;
+}, []>;
+export declare const createReadStream: jest.Mock<any, any>;
+export declare const writeFileSync: jest.Mock<any, any>;
+export declare const mkdirSync: jest.Mock<any, any>;

package/lib/__mocks__/fs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkdirSync = exports.writeFileSync = exports.createReadStream = exports.statSync = exports.readFileSync = exports.existsSync = void 0;
+exports.existsSync = jest.fn();
+exports.readFileSync = jest.fn(() => '');
+exports.statSync = jest.fn(() => ({ size: 0 }));
+exports.createReadStream = jest.fn();
+exports.writeFileSync = jest.fn();
+exports.mkdirSync = jest.fn();

package/lib/__mocks__/perf_hooks.d.ts

@@ -0,0 +1,3 @@
+export declare const performance: {
+    now: jest.Mock<any, any>;
+};

package/lib/__mocks__/perf_hooks.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performance = void 0;
+exports.performance = {
+    now: jest.fn(),
+};

package/lib/__mocks__/redoc.d.ts

@@ -0,0 +1,6 @@
+export declare const loadAndBundleSpec: jest.Mock<Promise<{
+    openapi: string;
+}>, []>;
+export declare const createStore: jest.Mock<Promise<{
+    toJS: jest.Mock<string, []>;
+}>, []>;

package/lib/__mocks__/redoc.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStore = exports.loadAndBundleSpec = void 0;
+exports.loadAndBundleSpec = jest.fn(() => Promise.resolve({ openapi: '3.0.0' }));
+exports.createStore = jest.fn(() => Promise.resolve({ toJS: jest.fn(() => '{}') }));

package/lib/__tests__/commands/build-docs.test.d.ts

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

package/lib/__tests__/commands/build-docs.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const redoc_1 = require("redoc");
+const server_1 = require("react-dom/server");
+const build_docs_1 = require("../../commands/build-docs");
+const utils_1 = require("../../commands/build-docs/utils");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+jest.mock('redoc');
+jest.mock('fs');
+jest.mock('../../utils/miscellaneous');
+const config = {
+    output: '',
+    title: 'Test',
+    disableGoogleFont: false,
+    templateFileName: '',
+    templateOptions: {},
+    redocOptions: {},
+};
+jest.mock('react-dom/server', () => ({
+    renderToString: jest.fn(),
+}));
+jest.mock('handlebars', () => ({
+    compile: jest.fn(() => jest.fn(() => '<html></html>')),
+}));
+describe('build-docs', () => {
+    it('should return correct html and call function for ssr', async () => {
+        const result = await (0, utils_1.getPageHTML)({}, '../some-path/openapi.yaml', {
+            ...config,
+            redocCurrentVersion: '2.0.0',
+        });
+        expect(server_1.renderToString).toBeCalledTimes(1);
+        expect(redoc_1.createStore).toBeCalledTimes(1);
+        expect(result).toBe('<html></html>');
+    });
+    it('should work correctly when calling handlerBuildCommand', async () => {
+        const processExitMock = jest.spyOn(process, 'exit').mockImplementation();
+        await (0, build_docs_1.handlerBuildCommand)({
+            argv: {
+                o: '',
+                title: 'test',
+                disableGoogleFont: false,
+                template: '',
+                templateOptions: {},
+                theme: { openapi: {} },
+                api: '../some-path/openapi.yaml',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(redoc_1.loadAndBundleSpec).toBeCalledTimes(1);
+        expect(miscellaneous_1.getFallbackApisOrExit).toBeCalledTimes(1);
+        expect(processExitMock).toBeCalledTimes(0);
+    });
+});

package/lib/__tests__/commands/bundle.test.d.ts

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