@redocly/cli 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @redocly/cli
+
+## 1.0.1
+
+### Patch Changes
+
+- Fixed the build-docs command failing when running outside the root folder.
+- Updated @redocly/openapi-core to v1.0.1.

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

@@ -34,10 +34,8 @@ const handlerBuildCommand = (argv, configFromFile) => __awaiter(void 0, void 0,
     const redocCurrentVersion = require('../../../package.json').dependencies.redoc.substring(1); // remove ~
     try {
         const elapsed = utils_2.getExecutionTime(startedAt);
-        const api = yield redoc_1.loadAndBundleSpec(openapi_core_1.isAbsoluteUrl(pathToApi)
-            ? pathToApi
-            : path_1.resolve(argv.config ? path_1.dirname(argv.config) : '', pathToApi));
-        const pageHTML = yield utils_1.getPageHTML(api, pathToApi, Object.assign(Object.assign({}, options), { redocCurrentVersion }));
+        const api = yield redoc_1.loadAndBundleSpec(openapi_core_1.isAbsoluteUrl(pathToApi) ? pathToApi : path_1.resolve(pathToApi));
+        const pageHTML = yield utils_1.getPageHTML(api, pathToApi, Object.assign(Object.assign({}, options), { redocCurrentVersion }), argv.config);
         fs_1.mkdirSync(path_1.dirname(options.output), { recursive: true });
         fs_1.writeFileSync(options.output, pageHTML);
         const sizeInKiB = Math.ceil(Buffer.byteLength(pageHTML) / 1024);

package/lib/commands/build-docs/utils.d.ts

@@ -1,7 +1,7 @@
 import { Config } from '@redocly/openapi-core';
 import type { BuildDocsOptions } from './types';
 export declare function getObjectOrJSON(openapiOptions: string | Record<string, unknown>, config: Config): JSON | Record<string, unknown> | Config;
-export declare function getPageHTML(api: any, pathToApi: string, { title, disableGoogleFont, templateFileName, templateOptions, redocOptions, redocCurrentVersion, }: BuildDocsOptions): Promise<string>;
+export declare function getPageHTML(api: any, pathToApi: string, { title, disableGoogleFont, templateFileName, templateOptions, redocOptions, redocCurrentVersion, }: BuildDocsOptions, configPath?: string): Promise<string>;
 export declare function sanitizeJSONString(str: string): string;
 export declare function escapeClosingScriptTag(str: string): string;
 export declare function escapeUnicode(str: string): string;

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

@@ -49,9 +49,9 @@ function getObjectOrJSON(openapiOptions, config) {
     return {};
 }
 exports.getObjectOrJSON = getObjectOrJSON;
-function getPageHTML(api, pathToApi, { title, disableGoogleFont, templateFileName, templateOptions, redocOptions = {}, redocCurrentVersion, }) {
+function getPageHTML(api, pathToApi, { title, disableGoogleFont, templateFileName, templateOptions, redocOptions = {}, redocCurrentVersion, }, configPath) {
     return __awaiter(this, void 0, void 0, function* () {
-        process.stderr.write('Prerendering docs');
+        process.stderr.write('Prerendering docs\n');
         const apiUrl = redocOptions.specUrl || (openapi_core_1.isAbsoluteUrl(pathToApi) ? pathToApi : undefined);
         const store = yield redoc_1.createStore(api, apiUrl, redocOptions);
         const sheet = new styled_components_1.ServerStyleSheet();
@@ -61,7 +61,7 @@ function getPageHTML(api, pathToApi, { title, disableGoogleFont, templateFileNam
         templateFileName = templateFileName
             ? templateFileName
             : (redocOptions === null || redocOptions === void 0 ? void 0 : redocOptions.htmlTemplate)
-                ? redocOptions.htmlTemplate
+                ? path_1.resolve(configPath ? path_1.dirname(configPath) : '', redocOptions.htmlTemplate)
                 : path_1.join(__dirname, './template.hbs');
         const template = handlebars_1.compile(fs_1.readFileSync(templateFileName).toString());
         return template({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "license": "MIT",
   "bin": {
@@ -34,7 +34,7 @@
     "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/openapi-core": "1.0.0",
+    "@redocly/openapi-core": "1.0.1",
     "assert-node-version": "^1.0.3",
     "chokidar": "^3.5.1",
     "colorette": "^1.2.0",

package/src/__mocks__/@redocly/openapi-core.ts

@@ -0,0 +1,80 @@
+import { ConfigFixture } from './../../__tests__/fixtures/config';
+import { Document } from '@redocly/openapi-core';
+import { firstDocument, secondDocument } from '../documents';
+
+export const __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(),
+  },
+};
+
+export const RedoclyClient = jest.fn(() => __redoclyClient);
+export const loadConfig = jest.fn(() => ConfigFixture);
+export const getMergedConfig = jest.fn();
+export const lint = jest.fn();
+export const bundle = jest.fn(() => ({ bundle: { parsed: null }, problems: null }));
+export const getTotals = jest.fn(() => ({ errors: 0 }));
+export const formatProblems = jest.fn();
+export const slash = jest.fn();
+export const findConfig = jest.fn();
+export const doesYamlFileExist = jest.fn();
+export const bundleDocument = jest.fn(() => Promise.resolve({ problems: {} }));
+export const detectOpenAPI = jest.fn();
+export const isAbsoluteUrl = jest.fn();
+
+export class BaseResolver {
+  cache = new Map<string, Promise<Document | ResolveError>>();
+
+  getFiles = jest.fn();
+  resolveExternalRef = jest.fn();
+  loadExternalRef = jest.fn;
+  parseDocument = jest.fn();
+  resolveDocument = jest
+    .fn()
+    .mockImplementationOnce(() =>
+      Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: firstDocument })
+    )
+    .mockImplementationOnce(() =>
+      Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: secondDocument })
+    );
+}
+
+export class ResolveError extends Error {
+  constructor(public originalError: Error) {
+    super(originalError.message);
+    Object.setPrototypeOf(this, ResolveError.prototype);
+  }
+}
+
+export class YamlParseError extends Error {
+  constructor(public originalError: Error) {
+    super(originalError.message);
+    Object.setPrototypeOf(this, YamlParseError.prototype);
+  }
+}
+
+export enum OasVersion {
+  Version2 = 'oas2',
+  Version3_0 = 'oas3_0',
+  Version3_1 = 'oas3_1',
+}
+
+export enum Oas3Operations {
+  get = 'get',
+  put = 'put',
+  post = 'post',
+  delete = 'delete',
+  options = 'options',
+  head = 'head',
+  patch = 'patch',
+  trace = 'trace',
+}

package/src/__mocks__/documents.ts

@@ -0,0 +1,63 @@
+export const firstDocument = {
+  openapi: '3.0.0',
+  servers: [{ url: 'http://localhost:8080' }],
+  info: {
+    description: 'example test',
+    version: '1.0.0',
+    title: 'Swagger Petstore',
+    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: {},
+};
+
+export const secondDocument = {
+  openapi: '3.0.0',
+  servers: [{ url: 'http://localhost:8080' }],
+  info: {
+    description: 'example test',
+    version: '1.0.0',
+    title: 'Swagger Petstore',
+    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: {},
+};

package/src/__mocks__/fs.ts

@@ -0,0 +1,6 @@
+export const existsSync = jest.fn();
+export const readFileSync = jest.fn(() => '');
+export const statSync = jest.fn(() => ({ size: 0 }));
+export const createReadStream = jest.fn();
+export const writeFileSync = jest.fn();
+export const mkdirSync = jest.fn();

package/src/__mocks__/perf_hooks.ts

@@ -0,0 +1,3 @@
+export const performance = {
+  now: jest.fn(),
+};

package/src/__mocks__/redoc.ts

@@ -0,0 +1,2 @@
+export const loadAndBundleSpec = jest.fn(() => Promise.resolve({ openapi: '3.0.0' }));
+export const createStore = jest.fn(() => Promise.resolve({ toJS: jest.fn(() => '{}') }));

package/src/__mocks__/utils.ts

@@ -0,0 +1,19 @@
+import { ConfigFixture } from '../__tests__/fixtures/config';
+
+export const getFallbackApisOrExit = jest.fn((entrypoints) =>
+  entrypoints.map((path: string) => ({ path }))
+);
+export const dumpBundle = jest.fn(() => '');
+export const slash = jest.fn();
+export const pluralize = jest.fn();
+export const getExecutionTime = jest.fn();
+export const printExecutionTime = jest.fn();
+export const printUnusedWarnings = jest.fn();
+export const printLintTotals = jest.fn();
+export const getOutputFileName = jest.fn(() => ({ outputFile: 'test.yaml', ext: 'yaml' }));
+export const handleError = jest.fn();
+export const exitWithError = jest.fn();
+export const writeYaml = jest.fn();
+export const loadConfigAndHandleErrors = jest.fn(() => ConfigFixture);
+export const checkIfRulesetExist = jest.fn();
+export const sortTopLevelKeysForOas = jest.fn((document) => document);

package/src/__tests__/commands/build-docs.test.ts

@@ -0,0 +1,62 @@
+import { createStore, loadAndBundleSpec } from 'redoc';
+import { renderToString } from 'react-dom/server';
+import { handlerBuildCommand } from '../../commands/build-docs';
+import { BuildDocsArgv } from '../../commands/build-docs/types';
+import { getPageHTML } from '../../commands/build-docs/utils';
+import { getFallbackApisOrExit } from '../../utils';
+
+jest.mock('redoc');
+jest.mock('fs');
+jest.mock('../../utils');
+
+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>')),
+}));
+
+jest.mock('mkdirp', () => ({
+  sync: jest.fn(),
+}));
+
+describe('build-docs', () => {
+  it('should return correct html and call function for ssr', async () => {
+    const result = await getPageHTML({}, '../some-path/openapi.yaml', {
+      ...config,
+      redocCurrentVersion: '2.0.0',
+    });
+    expect(renderToString).toBeCalledTimes(1);
+    expect(createStore).toBeCalledTimes(1);
+    expect(result).toBe('<html></html>');
+  });
+
+  it('should work correctly when calling handlerBuildCommand', async () => {
+    const processExitMock = jest.spyOn(process, 'exit').mockImplementation();
+    await handlerBuildCommand(
+      {
+        o: '',
+        title: 'test',
+        disableGoogleFont: false,
+        template: '',
+        templateOptions: {},
+        theme: { openapi: {} },
+        api: '../some-path/openapi.yaml',
+      } as BuildDocsArgv,
+      {} as any
+    );
+    expect(loadAndBundleSpec).toBeCalledTimes(1);
+    expect(getFallbackApisOrExit).toBeCalledTimes(1);
+    expect(processExitMock).toBeCalledTimes(0);
+  });
+});

package/src/__tests__/commands/bundle.test.ts

@@ -0,0 +1,150 @@
+import { lint, bundle, getTotals, getMergedConfig } from '@redocly/openapi-core';
+
+import { BundleOptions, handleBundle } from '../../commands/bundle';
+import { handleError } from '../../utils';
+import { commandWrapper } from '../../wrapper';
+import SpyInstance = jest.SpyInstance;
+import { Arguments } from 'yargs';
+
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+
+(getMergedConfig as jest.Mock).mockImplementation((config) => config);
+
+describe('bundle', () => {
+  let processExitMock: SpyInstance;
+  let exitCb: any;
+
+  beforeEach(() => {
+    processExitMock = jest.spyOn(process, 'exit').mockImplementation();
+    jest.spyOn(process, 'once').mockImplementation((_e, cb) => {
+      exitCb = cb;
+      return process.on(_e, cb);
+    });
+    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    (lint as jest.Mock).mockClear();
+    (bundle as jest.Mock).mockClear();
+    (getTotals as jest.Mock).mockReset();
+  });
+
+  it('bundles definitions w/o linting', async () => {
+    const apis = ['foo.yaml', 'bar.yaml'];
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'yaml',
+      format: 'codeframe',
+    } as Arguments<BundleOptions>);
+
+    expect(lint).toBeCalledTimes(0);
+    expect(bundle).toBeCalledTimes(apis.length);
+  });
+
+  it('exits with code 0 when bundles definitions', async () => {
+    const apis = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'yaml',
+      format: 'codeframe',
+    } as Arguments<BundleOptions>);
+
+    await exitCb?.();
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('bundles definitions w/ linting', async () => {
+    const apis = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+
+    (getTotals as jest.Mock).mockReturnValue({
+      errors: 0,
+      warnings: 0,
+      ignored: 0,
+    });
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'yaml',
+      format: 'codeframe',
+      lint: true,
+    } as Arguments<BundleOptions>);
+
+    expect(lint).toBeCalledTimes(apis.length);
+    expect(bundle).toBeCalledTimes(apis.length);
+  });
+
+  it('exits with code 0 when bundles definitions w/linting w/o errors', async () => {
+    const apis = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'yaml',
+      format: 'codeframe',
+      lint: true,
+    } as Arguments<BundleOptions>);
+
+    await exitCb?.();
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('exits with code 1 when bundles definitions w/linting w/errors', async () => {
+    const apis = ['foo.yaml'];
+
+    (getTotals as jest.Mock).mockReturnValue({
+      errors: 1,
+      warnings: 0,
+      ignored: 0,
+    });
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'yaml',
+      format: 'codeframe',
+      lint: true,
+    } as Arguments<BundleOptions>);
+
+    expect(lint).toBeCalledTimes(apis.length);
+    await exitCb?.();
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('handleError is called when bundles an invalid definition', async () => {
+    const apis = ['invalid.json'];
+
+    (bundle as jest.Mock).mockImplementationOnce(() => {
+      throw new Error('Invalid definition');
+    });
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'json',
+      format: 'codeframe',
+      lint: false,
+    } as Arguments<BundleOptions>);
+
+    expect(handleError).toHaveBeenCalledTimes(1);
+    expect(handleError).toHaveBeenCalledWith(new Error('Invalid definition'), 'invalid.json');
+  });
+
+  it("handleError isn't called when bundles a valid definition", async () => {
+    const apis = ['foo.yaml'];
+
+    (getTotals as jest.Mock).mockReturnValue({
+      errors: 0,
+      warnings: 0,
+      ignored: 0,
+    });
+
+    await commandWrapper(handleBundle)({
+      apis,
+      ext: 'yaml',
+      format: 'codeframe',
+      lint: false,
+    } as Arguments<BundleOptions>);
+
+    expect(handleError).toHaveBeenCalledTimes(0);
+  });
+});

package/src/__tests__/commands/join.test.ts

@@ -0,0 +1,122 @@
+import { handleJoin } from '../../commands/join';
+import { exitWithError, writeYaml } from '../../utils';
+import { yellow } from 'colorette';
+import { detectOpenAPI } from '@redocly/openapi-core';
+import { loadConfig } from '../../__mocks__/@redocly/openapi-core';
+import { ConfigFixture } from '../fixtures/config';
+
+jest.mock('../../utils');
+jest.mock('colorette');
+
+describe('handleJoin fails', () => {
+  const colloreteYellowMock = yellow as jest.Mock<any, any>;
+  colloreteYellowMock.mockImplementation((string: string) => string);
+
+  it('should call exitWithError because only one entrypoint', async () => {
+    await handleJoin({ apis: ['first.yaml'] }, {} as any, 'cli-version');
+    expect(exitWithError).toHaveBeenCalledWith(`At least 2 apis should be provided. \n\n`);
+  });
+
+  it('should call exitWithError because passed all 3 options for tags', async () => {
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+        'prefix-tags-with-info-prop': 'something',
+        'without-x-tag-groups': true,
+        'prefix-tags-with-filename': true,
+      },
+      {} as any,
+      'cli-version'
+    );
+
+    expect(exitWithError).toHaveBeenCalledWith(
+      `You use prefix-tags-with-filename, prefix-tags-with-info-prop, without-x-tag-groups together.\nPlease choose only one! \n\n`
+    );
+  });
+
+  it('should call exitWithError because passed all 2 options for tags', async () => {
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+        'without-x-tag-groups': true,
+        'prefix-tags-with-filename': true,
+      },
+      {} as any,
+      'cli-version'
+    );
+
+    expect(exitWithError).toHaveBeenCalledWith(
+      `You use prefix-tags-with-filename, without-x-tag-groups together.\nPlease choose only one! \n\n`
+    );
+  });
+
+  it('should call exitWithError because Only OpenAPI 3 is supported', async () => {
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+      },
+      ConfigFixture as any,
+      'cli-version'
+    );
+    expect(exitWithError).toHaveBeenCalledWith('Only OpenAPI 3 is supported: undefined \n\n');
+  });
+
+  it('should call writeYaml function', async () => {
+    (detectOpenAPI as jest.Mock).mockReturnValue('oas3_0');
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+      },
+      ConfigFixture as any,
+      'cli-version'
+    );
+
+    expect(writeYaml).toHaveBeenCalledWith(expect.any(Object), 'openapi.yaml', expect.any(Boolean));
+  });
+
+  it('should call writeYaml function with custom output file', async () => {
+    (detectOpenAPI as jest.Mock).mockReturnValue('oas3_0');
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+        output: 'output.yml',
+      },
+      ConfigFixture as any,
+      'cli-version'
+    );
+
+    expect(writeYaml).toHaveBeenCalledWith(expect.any(Object), 'output.yml', expect.any(Boolean));
+  });
+
+  it('should call skipDecorators and skipPreprocessors', async () => {
+    (detectOpenAPI as jest.Mock).mockReturnValue('oas3_0');
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+      },
+      ConfigFixture as any,
+      'cli-version'
+    );
+
+    const config = loadConfig();
+    expect(config.styleguide.skipDecorators).toHaveBeenCalled();
+    expect(config.styleguide.skipPreprocessors).toHaveBeenCalled();
+  });
+
+  it('should not call skipDecorators and skipPreprocessors', async () => {
+    (detectOpenAPI as jest.Mock).mockReturnValue('oas3_0');
+    await handleJoin(
+      {
+        apis: ['first.yaml', 'second.yaml'],
+        decorate: true,
+        preprocess: true,
+      },
+      ConfigFixture as any,
+      'cli-version'
+    );
+
+    const config = loadConfig();
+    expect(config.styleguide.skipDecorators).not.toHaveBeenCalled();
+    expect(config.styleguide.skipPreprocessors).not.toHaveBeenCalled();
+  });
+});