@redocly/cli 1.0.0-beta.104 → 1.0.0-beta.107

package/src/commands/split/__tests__/index.test.ts

@@ -1,9 +1,7 @@
 import { iteratePathItems, handleSplit } from '../index';
 import * as path from 'path';
 import * as openapiCore from '@redocly/openapi-core';
-import {
-  ComponentsFiles,
-} from '../types'; 
+import { ComponentsFiles } from '../types';
 import { blue, green } from 'colorette';
 
 const utils = require('../../../utils');
@@ -23,16 +21,14 @@ describe('#split', () => {
   const componentsFiles: ComponentsFiles = {};
 
   it('should split the file and show the success message', async () => {
-    const filePath = "packages/cli/src/commands/split/__tests__/fixtures/spec.json";
+    const filePath = 'packages/cli/src/commands/split/__tests__/fixtures/spec.json';
     jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
 
-    await handleSplit (
-      {
-        entrypoint: filePath,
-        outDir: openapiDir,
-        separator: '_',
-      }
-    );
+    await handleSplit({
+      api: filePath,
+      outDir: openapiDir,
+      separator: '_',
+    });
 
     expect(process.stderr.write).toBeCalledTimes(2);
     expect((process.stderr.write as jest.Mock).mock.calls[0][0]).toBe(
@@ -44,65 +40,86 @@ describe('#split', () => {
     );
   });
 
-
   it('should use the correct separator', async () => {
-    const filePath = "packages/cli/src/commands/split/__tests__/fixtures/spec.json";
+    const filePath = 'packages/cli/src/commands/split/__tests__/fixtures/spec.json';
 
     jest.spyOn(utils, 'pathToFilename').mockImplementation(() => 'newFilePath');
 
-    await handleSplit (
-      {
-        entrypoint: filePath,
-        outDir: openapiDir,
-        separator: '_',
-      }
-    );
+    await handleSplit({
+      api: filePath,
+      outDir: openapiDir,
+      separator: '_',
+    });
 
     expect(utils.pathToFilename).toBeCalledWith(expect.anything(), '_');
     utils.pathToFilename.mockRestore();
   });
 
   it('should have correct path with paths', () => {
-    const openapi = require("./fixtures/spec.json");
-    
+    const openapi = require('./fixtures/spec.json');
+
     jest.spyOn(openapiCore, 'slash').mockImplementation(() => 'paths/test.yaml');
     jest.spyOn(path, 'relative').mockImplementation(() => 'paths/test.yaml');
-    iteratePathItems(openapi.paths, openapiDir, path.join(openapiDir, 'paths'), componentsFiles, '_');
+    iteratePathItems(
+      openapi.paths,
+      openapiDir,
+      path.join(openapiDir, 'paths'),
+      componentsFiles,
+      '_'
+    );
 
     expect(openapiCore.slash).toHaveBeenCalledWith('paths/test.yaml');
     expect(path.relative).toHaveBeenCalledWith('test', 'test/paths/test.yaml');
   });
 
   it('should have correct path with webhooks', () => {
-    const openapi = require("./fixtures/webhooks.json");
+    const openapi = require('./fixtures/webhooks.json');
 
     jest.spyOn(openapiCore, 'slash').mockImplementation(() => 'webhooks/test.yaml');
     jest.spyOn(path, 'relative').mockImplementation(() => 'webhooks/test.yaml');
-    iteratePathItems(openapi.webhooks, openapiDir, path.join(openapiDir, 'webhooks'), componentsFiles, 'webhook_');
+    iteratePathItems(
+      openapi.webhooks,
+      openapiDir,
+      path.join(openapiDir, 'webhooks'),
+      componentsFiles,
+      'webhook_'
+    );
 
     expect(openapiCore.slash).toHaveBeenCalledWith('webhooks/test.yaml');
     expect(path.relative).toHaveBeenCalledWith('test', 'test/webhooks/test.yaml');
   });
 
   it('should have correct path with x-webhooks', () => {
-    const openapi = require("./fixtures/spec.json");
+    const openapi = require('./fixtures/spec.json');
 
     jest.spyOn(openapiCore, 'slash').mockImplementation(() => 'webhooks/test.yaml');
     jest.spyOn(path, 'relative').mockImplementation(() => 'webhooks/test.yaml');
-    iteratePathItems(openapi['x-webhooks'], openapiDir, path.join(openapiDir, 'webhooks'), componentsFiles, 'webhook_');
+    iteratePathItems(
+      openapi['x-webhooks'],
+      openapiDir,
+      path.join(openapiDir, 'webhooks'),
+      componentsFiles,
+      'webhook_'
+    );
 
     expect(openapiCore.slash).toHaveBeenCalledWith('webhooks/test.yaml');
     expect(path.relative).toHaveBeenCalledWith('test', 'test/webhooks/test.yaml');
   });
 
   it('should create correct folder name for code samples', async () => {
-    const openapi = require("./fixtures/samples.json");
+    const openapi = require('./fixtures/samples.json');
 
-    const fs = require('fs')
+    const fs = require('fs');
     jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
 
     jest.spyOn(utils, 'escapeLanguageName');
-    iteratePathItems(openapi.paths, openapiDir, path.join(openapiDir, 'paths'), componentsFiles, '_');
+    iteratePathItems(
+      openapi.paths,
+      openapiDir,
+      path.join(openapiDir, 'paths'),
+      componentsFiles,
+      '_'
+    );
 
     expect(utils.escapeLanguageName).nthCalledWith(1, 'C#');
     expect(utils.escapeLanguageName).nthReturnedWith(1, 'C_sharp');

package/src/commands/split/index.ts

@@ -5,7 +5,14 @@ import * as path from 'path';
 import { performance } from 'perf_hooks';
 const isEqual = require('lodash.isequal');
 
-import { printExecutionTime, pathToFilename, readYaml, writeYaml, exitWithError, escapeLanguageName } from '../../utils';
+import {
+  printExecutionTime,
+  pathToFilename,
+  readYaml,
+  writeYaml,
+  exitWithError,
+  escapeLanguageName,
+} from '../../utils';
 import { isString, isObject, isEmptyObject } from '../../js-utils';
 import {
   Definition,
@@ -23,42 +30,56 @@ import {
   componentsPath,
   OPENAPI3_METHOD_NAMES,
   OPENAPI3_COMPONENT_NAMES,
-  Referenced
+  Referenced,
 } from './types';
 
-export async function handleSplit (argv: {
-  entrypoint: string;
-  outDir: string
-  separator: string
-}) {
+export async function handleSplit(argv: { api: string; outDir: string; separator: string }) {
   const startedAt = performance.now();
-  const { entrypoint, outDir, separator } = argv;
-  validateDefinitionFileName(entrypoint!);
-  const openapi = readYaml(entrypoint!) as Oas3Definition | Oas3_1Definition;
+  const { api, outDir, separator } = argv;
+  validateDefinitionFileName(api!);
+  const openapi = readYaml(api!) as Oas3Definition | Oas3_1Definition;
   splitDefinition(openapi, outDir, separator);
   process.stderr.write(
-    `🪓 Document: ${blue(entrypoint!)} ${green('is successfully split')}
-    and all related files are saved to the directory: ${blue(outDir)} \n`,
+    `🪓 Document: ${blue(api!)} ${green('is successfully split')}
+    and all related files are saved to the directory: ${blue(outDir)} \n`
   );
-  printExecutionTime('split', startedAt, entrypoint!);
+  printExecutionTime('split', startedAt, api!);
 }
 
-function splitDefinition(openapi: Oas3Definition | Oas3_1Definition, openapiDir: string, pathSeparator: string) {
+function splitDefinition(
+  openapi: Oas3Definition | Oas3_1Definition,
+  openapiDir: string,
+  pathSeparator: string
+) {
   fs.mkdirSync(openapiDir, { recursive: true });
 
   const componentsFiles: ComponentsFiles = {};
   iterateComponents(openapi, openapiDir, componentsFiles);
-  iteratePathItems(openapi.paths, openapiDir, path.join(openapiDir, 'paths'), componentsFiles, pathSeparator);
-  const webhooks = (openapi as Oas3_1Definition).webhooks || (openapi as Oas3Definition)['x-webhooks'];
+  iteratePathItems(
+    openapi.paths,
+    openapiDir,
+    path.join(openapiDir, 'paths'),
+    componentsFiles,
+    pathSeparator
+  );
+  const webhooks =
+    (openapi as Oas3_1Definition).webhooks || (openapi as Oas3Definition)['x-webhooks'];
   // use webhook_ prefix for code samples to prevent potential name-clashes with paths samples
-  iteratePathItems(webhooks, openapiDir, path.join(openapiDir, 'webhooks'), componentsFiles, pathSeparator, 'webhook_');
+  iteratePathItems(
+    webhooks,
+    openapiDir,
+    path.join(openapiDir, 'webhooks'),
+    componentsFiles,
+    pathSeparator,
+    'webhook_'
+  );
 
   replace$Refs(openapi, openapiDir, componentsFiles);
   writeYaml(openapi, path.join(openapiDir, 'openapi.yaml'));
 }
 
 function isStartsWithComponents(node: string) {
-  return node.startsWith(componentsPath)
+  return node.startsWith(componentsPath);
 }
 
 function isNotYaml(filename: string) {
@@ -77,7 +98,10 @@ function validateDefinitionFileName(fileName: string) {
   if (!fs.existsSync(fileName)) exitWithError(`File ${blue(fileName)} does not exist \n`);
   const file = loadFile(fileName);
   if ((file as Oas2Definition).swagger) exitWithError('OpenAPI 2 is not supported by this command');
-  if (!(file as Oas3Definition | Oas3_1Definition).openapi) exitWithError('File does not conform to the OpenAPI Specification. OpenAPI version is not specified');
+  if (!(file as Oas3Definition | Oas3_1Definition).openapi)
+    exitWithError(
+      'File does not conform to the OpenAPI Specification. OpenAPI version is not specified'
+    );
   return true;
 }
 
@@ -90,8 +114,8 @@ function langToExt(lang: string) {
     bash: '.sh',
     javascript: '.js',
     js: '.js',
-    python: '.py'
-  }
+    python: '.py',
+  };
   return langObj[lang];
 }
 
@@ -111,7 +135,7 @@ function traverseDirectoryDeep(directory: string, callback: any, componentsFiles
 function traverseDirectoryDeepCallback(
   filename: string,
   directory: string,
-  componentsFiles: object,
+  componentsFiles: object
 ) {
   if (isNotYaml(filename)) return;
   const pathData = readYaml(filename);
@@ -127,11 +151,7 @@ function crawl(object: any, visitor: any) {
   }
 }
 
-function replace$Refs(
-  obj: any,
-  relativeFrom: string,
-  componentFiles = {} as ComponentsFiles
-) {
+function replace$Refs(obj: any, relativeFrom: string, componentFiles = {} as ComponentsFiles) {
   crawl(obj, (node: any) => {
     if (node.$ref && isString(node.$ref) && isStartsWithComponents(node.$ref)) {
       replace(node, '$ref');
@@ -156,7 +176,9 @@ function replace$Refs(
     const filesGroupName = componentFiles[groupName];
     if (!filesGroupName || !filesGroupName[name!]) return;
     let filename = path.relative(relativeFrom, filesGroupName[name!].filename);
-    if (!filename.startsWith('.')) { filename = '.' + path.sep + filename; }
+    if (!filename.startsWith('.')) {
+      filename = '.' + path.sep + filename;
+    }
     node[key] = filename;
   }
 }
@@ -182,30 +204,40 @@ function implicitlyReferenceDiscriminator(
   const discriminatorEnum = discriminatorPropSchema && discriminatorPropSchema.enum;
   const mapping = (obj.discriminator.mapping = obj.discriminator.mapping || {});
   for (const name of Object.keys(implicitMapping)) {
-    if (discriminatorEnum && !discriminatorEnum.includes(name)) { continue; }
+    if (discriminatorEnum && !discriminatorEnum.includes(name)) {
+      continue;
+    }
     if (mapping[name] && mapping[name] !== implicitMapping[name]) {
-      process.stderr.write(yellow(
-        `warning: explicit mapping overlaps with local mapping entry ${red(name)} at ${blue(filename)}. Please check it.`
-      ));
+      process.stderr.write(
+        yellow(
+          `warning: explicit mapping overlaps with local mapping entry ${red(name)} at ${blue(
+            filename
+          )}. Please check it.`
+        )
+      );
     }
     mapping[name] = implicitMapping[name];
   }
 }
 
 function isNotSecurityComponentType(componentType: string) {
-  return componentType !== OPENAPI3_COMPONENT.SecuritySchemes
+  return componentType !== OPENAPI3_COMPONENT.SecuritySchemes;
 }
 
 function findComponentTypes(components: any) {
-  return OPENAPI3_COMPONENT_NAMES
-    .filter(item => isNotSecurityComponentType(item) && Object.keys(components).includes(item))
+  return OPENAPI3_COMPONENT_NAMES.filter(
+    (item) => isNotSecurityComponentType(item) && Object.keys(components).includes(item)
+  );
 }
 
 function doesFileDiffer(filename: string, componentData: any) {
   return fs.existsSync(filename) && !isEqual(readYaml(filename), componentData);
 }
 
-function removeEmptyComponents(openapi: Oas3Definition | Oas3_1Definition, componentType: Oas3ComponentName) {
+function removeEmptyComponents(
+  openapi: Oas3Definition | Oas3_1Definition,
+  componentType: Oas3ComponentName
+) {
   if (openapi.components && isEmptyObject(openapi.components[componentType])) {
     delete openapi.components[componentType];
   }
@@ -237,19 +269,21 @@ function gatherComponentsFiles(
 ) {
   let inherits = [];
   if (componentType === OPENAPI3_COMPONENT.Schemas) {
-    inherits = ((components?.[componentType]?.[componentName] as Oas3Schema)?.allOf || []).map((s: any) => s.$ref).filter(Boolean);
+    inherits = ((components?.[componentType]?.[componentName] as Oas3Schema)?.allOf || [])
+      .map((s: any) => s.$ref)
+      .filter(Boolean);
   }
   componentsFiles[componentType] = componentsFiles[componentType] || {};
   componentsFiles[componentType][componentName] = { inherits, filename };
 }
 
 function iteratePathItems(
-  pathItems: Record<string,  Referenced<Oas3PathItem>> | undefined,
+  pathItems: Record<string, Referenced<Oas3PathItem>> | undefined,
   openapiDir: string,
   outDir: string,
   componentsFiles: object,
   pathSeparator: string,
-  codeSamplesPathPrefix: string = '',
+  codeSamplesPathPrefix: string = ''
 ) {
   if (!pathItems) return;
   fs.mkdirSync(outDir, { recursive: true });
@@ -259,7 +293,7 @@ function iteratePathItems(
     const pathData = pathItems[pathName] as Oas3PathItem;
 
     if (isRef(pathData)) continue;
-    
+
     for (const method of OPENAPI3_METHOD_NAMES) {
       const methodData = pathData[method];
       const methodDataXCode = methodData?.['x-code-samples'] || methodData?.['x-codeSamples'];
@@ -273,20 +307,20 @@ function iteratePathItems(
           'code_samples',
           escapeLanguageName(sample.lang),
           codeSamplesPathPrefix + pathToFilename(pathName, pathSeparator),
-          method + langToExt(sample.lang),
+          method + langToExt(sample.lang)
         );
 
         fs.mkdirSync(path.dirname(sampleFileName), { recursive: true });
         fs.writeFileSync(sampleFileName, sample.source);
         // @ts-ignore
         sample.source = {
-          $ref: slash(path.relative(outDir, sampleFileName))
+          $ref: slash(path.relative(outDir, sampleFileName)),
         };
       }
     }
     writeYaml(pathData, pathFile);
     pathItems[pathName] = {
-      $ref: slash(path.relative(openapiDir, pathFile))
+      $ref: slash(path.relative(openapiDir, pathFile)),
     };
 
     traverseDirectoryDeep(outDir, traverseDirectoryDeepCallback, componentsFiles);
@@ -329,9 +363,13 @@ function iterateComponents(
         );
 
         if (doesFileDiffer(filename, componentData)) {
-          process.stderr.write(yellow(
-            `warning: conflict for ${componentName} - file already exists with different content: ${blue(filename)} ... Skip.\n`
-          ));
+          process.stderr.write(
+            yellow(
+              `warning: conflict for ${componentName} - file already exists with different content: ${blue(
+                filename
+              )} ... Skip.\n`
+            )
+          );
         } else {
           writeYaml(componentData, filename);
         }

package/src/commands/split/types.ts

@@ -9,9 +9,21 @@ import {
   Oas3ComponentName,
   Oas3_1Webhooks,
   Oas2Definition,
-  Referenced
-} from "@redocly/openapi-core";
-export { Oas3_1Definition, Oas3Definition, Oas2Definition, Oas3Components, Oas3Paths, Oas3PathItem, Oas3ComponentName, Oas3_1Schema, Oas3Schema, Oas3_1Webhooks, Referenced }
+  Referenced,
+} from '@redocly/openapi-core';
+export {
+  Oas3_1Definition,
+  Oas3Definition,
+  Oas2Definition,
+  Oas3Components,
+  Oas3Paths,
+  Oas3PathItem,
+  Oas3ComponentName,
+  Oas3_1Schema,
+  Oas3Schema,
+  Oas3_1Webhooks,
+  Referenced,
+};
 export type Definition = Oas3_1Definition | Oas3Definition | Oas2Definition;
 export interface ComponentsFiles {
   [schemas: string]: any;
@@ -34,7 +46,7 @@ enum OPENAPI3_METHOD {
   Options = 'options',
   Head = 'head',
   Patch = 'patch',
-  Trace = 'trace'
+  Trace = 'trace',
 }
 
 export const OPENAPI3_METHOD_NAMES: OPENAPI3_METHOD[] = [
@@ -45,7 +57,7 @@ export const OPENAPI3_METHOD_NAMES: OPENAPI3_METHOD[] = [
   OPENAPI3_METHOD.Options,
   OPENAPI3_METHOD.Head,
   OPENAPI3_METHOD.Patch,
-  OPENAPI3_METHOD.Trace
+  OPENAPI3_METHOD.Trace,
 ];
 
 export enum OPENAPI3_COMPONENT {
@@ -57,7 +69,7 @@ export enum OPENAPI3_COMPONENT {
   RequestBodies = 'requestBodies',
   Links = 'links',
   Callbacks = 'callbacks',
-  SecuritySchemes = 'securitySchemes'
+  SecuritySchemes = 'securitySchemes',
 }
 
 export const OPENAPI3_COMPONENT_NAMES: OPENAPI3_COMPONENT[] = [
@@ -69,5 +81,5 @@ export const OPENAPI3_COMPONENT_NAMES: OPENAPI3_COMPONENT[] = [
   OPENAPI3_COMPONENT.Headers,
   OPENAPI3_COMPONENT.Links,
   OPENAPI3_COMPONENT.Callbacks,
-  OPENAPI3_COMPONENT.SecuritySchemes
+  OPENAPI3_COMPONENT.SecuritySchemes,
 ];

package/src/commands/stats.ts

@@ -2,7 +2,7 @@ import { performance } from 'perf_hooks';
 import * as colors from 'colorette';
 import {
   Config,
-  LintConfig,
+  StyleguideConfig,
   loadConfig,
   normalizeTypes,
   Oas3Types,
@@ -18,22 +18,22 @@ import {
   WalkContext,
   walkDocument,
   Stats,
-  bundle
+  bundle,
 } from '@redocly/openapi-core';
 
-import { getFallbackEntryPointsOrExit } from '../utils'
+import { getFallbackApisOrExit } from '../utils';
 import { printExecutionTime } from '../utils';
 
 const statsAccumulator: StatsAccumulator = {
   refs: { metric: '🚗 References', total: 0, color: 'red', items: new Set() },
   externalDocs: { metric: '📦 External Documents', total: 0, color: 'magenta' },
-  schemas: { metric: '📈 Schemas', total: 0, color: 'white'},
+  schemas: { metric: '📈 Schemas', total: 0, color: 'white' },
   parameters: { metric: '👉 Parameters', total: 0, color: 'yellow', items: new Set() },
   links: { metric: '🔗 Links', total: 0, color: 'cyan', items: new Set() },
   pathItems: { metric: '➡️ Path Items', total: 0, color: 'green' },
   operations: { metric: '👷 Operations', total: 0, color: 'yellow' },
   tags: { metric: '🔖 Tags', total: 0, color: 'white', items: new Set() },
-}
+};
 
 function printStatsStylish(statsAccumulator: StatsAccumulator) {
   for (const node in statsAccumulator) {
@@ -48,35 +48,35 @@ function printStatsJson(statsAccumulator: StatsAccumulator) {
     json[key] = {
       metric: statsAccumulator[key as StatsName].metric,
       total: statsAccumulator[key as StatsName].total,
-    }
+    };
   }
   process.stdout.write(JSON.stringify(json, null, 2));
 }
 
-function printStats(statsAccumulator: StatsAccumulator, entrypoint: string, format: string) {
-  process.stderr.write(`Document: ${colors.magenta(entrypoint)} stats:\n\n`);
+function printStats(statsAccumulator: StatsAccumulator, api: string, format: string) {
+  process.stderr.write(`Document: ${colors.magenta(api)} stats:\n\n`);
   switch (format) {
-    case 'stylish': printStatsStylish(statsAccumulator); break;
-    case 'json': printStatsJson(statsAccumulator); break;
+    case 'stylish':
+      printStatsStylish(statsAccumulator);
+      break;
+    case 'json':
+      printStatsJson(statsAccumulator);
+      break;
   }
 }
 
-export async function handleStats (argv: {
-  config?: string;
-  entrypoint?: string;
-  format: string;
-}) {
+export async function handleStats(argv: { config?: string; api?: string; format: string }) {
   const config: Config = await loadConfig(argv.config);
-  const [{ path }] = await getFallbackEntryPointsOrExit(argv.entrypoint ? [argv.entrypoint] : [], config);
+  const [{ path }] = await getFallbackApisOrExit(argv.api ? [argv.api] : [], config);
   const externalRefResolver = new BaseResolver(config.resolve);
   const { bundle: document } = await bundle({ config, ref: path });
-  const lintConfig: LintConfig = config.lint;
+  const lintConfig: StyleguideConfig = config.styleguide;
   const oasVersion = detectOpenAPI(document.parsed);
   const oasMajorVersion = openAPIMajor(oasVersion);
   const types = normalizeTypes(
     lintConfig.extendTypes(
       oasMajorVersion === OasMajorVersion.Version3 ? Oas3Types : Oas2Types,
-      oasVersion,
+      oasVersion
     ),
     lintConfig
   );
@@ -86,7 +86,7 @@ export async function handleStats (argv: {
     problems: [],
     oasVersion: oasVersion,
     visitorsData: {},
-  }
+  };
 
   const resolvedRefMap = await resolveDocument({
     rootDocument: document,
@@ -94,11 +94,14 @@ export async function handleStats (argv: {
     externalRefResolver,
   });
 
-  const statsVisitor = normalizeVisitors([{
-    severity: 'warn',
-    ruleId: 'stats',
-    visitor: Stats(statsAccumulator)
-  }],
+  const statsVisitor = normalizeVisitors(
+    [
+      {
+        severity: 'warn',
+        ruleId: 'stats',
+        visitor: Stats(statsAccumulator),
+      },
+    ],
     types
   );