@redocly/cli 1.0.0-beta.108 → 1.0.0-beta.109

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

@@ -1,4 +1,6 @@
 import { ConfigFixture } from './../../__tests__/fixtures/config';
+import { Document, ResolveError } from '@redocly/openapi-core';
+import { firstDocument, secondDocument } from '../documents';
 
 export const __redoclyClient = {
   isAuthorizedWithRedocly: jest.fn().mockResolvedValue(true),
@@ -25,3 +27,39 @@ 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 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 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__/utils.ts

@@ -11,3 +11,4 @@ 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();

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

@@ -1,6 +1,7 @@
 import { handleJoin } from '../../commands/join';
-import { exitWithError } from '../../utils';
+import { exitWithError, writeYaml } from '../../utils';
 import { yellow } from 'colorette';
+import { detectOpenAPI } from '@redocly/openapi-core';
 
 jest.mock('../../utils');
 jest.mock('colorette');
@@ -44,4 +45,25 @@ describe('handleJoin fails', () => {
       `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'],
+      },
+      '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'],
+      },
+      'cli-version'
+    );
+    expect(writeYaml).toHaveBeenCalled();
+  });
 });

package/src/commands/join.ts

@@ -26,7 +26,9 @@ import {
   writeYaml,
   exitWithError,
 } from '../utils';
-import { isObject, isString } from '../js-utils';
+import { isObject, isString, keysOf } from '../js-utils';
+import { Oas3Parameter, Oas3PathItem, Oas3Server } from '@redocly/openapi-core/lib/typings/openapi';
+import { OPENAPI3_METHOD } from './split/types';
 
 const COMPONENTS = 'components';
 const Tags = 'tags';
@@ -332,73 +334,180 @@ export async function handleJoin(argv: JoinArgv, packageVersion: string) {
     { apiFilename, api, potentialConflicts, tagsPrefix, componentsPrefix }: JoinDocumentContext
   ) {
     const { paths } = openapi;
+    const operationsSet = new Set(keysOf<typeof OPENAPI3_METHOD>(OPENAPI3_METHOD));
     if (paths) {
       if (!joinedDef.hasOwnProperty('paths')) {
         joinedDef['paths'] = {};
       }
-      for (const path of Object.keys(paths)) {
+
+      for (const path of keysOf(paths)) {
         if (!joinedDef.paths.hasOwnProperty(path)) {
           joinedDef.paths[path] = {};
         }
         if (!potentialConflicts.paths.hasOwnProperty(path)) {
           potentialConflicts.paths[path] = {};
         }
-        for (const [operation, pathOperation] of Object.entries(paths[path])) {
-          joinedDef.paths[path][operation] = pathOperation;
-          potentialConflicts.paths[path][operation] = [
-            ...(potentialConflicts.paths[path][operation] || []),
-            api,
-          ];
-          const { operationId } = pathOperation;
-          if (operationId) {
-            if (!potentialConflicts.paths.hasOwnProperty('operationIds')) {
-              potentialConflicts.paths['operationIds'] = {};
-            }
-            potentialConflicts.paths.operationIds[operationId] = [
-              ...(potentialConflicts.paths.operationIds[operationId] || []),
-              api,
-            ];
+
+        const pathItem = paths[path] as Oas3PathItem;
+
+        for (const field of keysOf(pathItem)) {
+          if (operationsSet.has(field as OPENAPI3_METHOD)) {
+            collectPathOperation(pathItem, path, field as OPENAPI3_METHOD);
           }
-          const { tags, security } = joinedDef.paths[path][operation];
-          if (tags) {
-            joinedDef.paths[path][operation].tags = tags.map((tag: string) =>
-              addPrefix(tag, tagsPrefix)
-            );
-            populateTags({
-              api,
-              apiFilename,
-              tags: formatTags(tags),
-              potentialConflicts,
-              tagsPrefix,
-              componentsPrefix,
-            });
-          } else {
-            joinedDef.paths[path][operation]['tags'] = [
-              addPrefix('other', tagsPrefix || apiFilename),
-            ];
-            populateTags({
-              api,
-              apiFilename,
-              tags: formatTags(['other']),
-              potentialConflicts,
-              tagsPrefix: tagsPrefix || apiFilename,
-              componentsPrefix,
-            });
+          if (field === 'servers') {
+            collectPathServers(pathItem, path);
           }
-          if (!security && openapi.hasOwnProperty('security')) {
-            joinedDef.paths[path][operation]['security'] = addSecurityPrefix(
-              openapi.security,
-              componentsPrefix!
-            );
-          } else if (pathOperation.security) {
-            joinedDef.paths[path][operation].security = addSecurityPrefix(
-              pathOperation.security,
-              componentsPrefix!
-            );
+          if (field === 'parameters') {
+            collectPathParameters(pathItem, path);
+          }
+          if (typeof pathItem[field] === 'string') {
+            collectPathStringFields(pathItem, path, field);
           }
         }
       }
     }
+
+    function collectPathStringFields(
+      pathItem: Oas3PathItem,
+      path: string | number,
+      field: keyof Oas3PathItem
+    ) {
+      const fieldValue = pathItem[field];
+      if (
+        joinedDef.paths[path].hasOwnProperty(field) &&
+        joinedDef.paths[path][field] !== fieldValue
+      ) {
+        process.stderr.write(yellow(`warning: different ${field} values in ${path}\n`));
+        return;
+      }
+      joinedDef.paths[path][field] = fieldValue;
+    }
+
+    function collectPathServers(pathItem: Oas3PathItem, path: string | number) {
+      if (!pathItem.servers) {
+        return;
+      }
+
+      if (!joinedDef.paths[path].hasOwnProperty('servers')) {
+        joinedDef.paths[path].servers = [];
+      }
+
+      for (const server of pathItem.servers) {
+        let isFoundServer = false;
+        for (const pathServer of joinedDef.paths[path].servers) {
+          if (pathServer.url === server.url) {
+            if (!isServersEqual(pathServer, server)) {
+              exitWithError(`Different server values for (${server.url}) in ${path}`);
+            }
+            isFoundServer = true;
+          }
+        }
+
+        if (!isFoundServer) {
+          joinedDef.paths[path].servers.push(server);
+        }
+      }
+    }
+
+    function collectPathParameters(pathItem: Oas3PathItem, path: string | number) {
+      if (!pathItem.parameters) {
+        return;
+      }
+      if (!joinedDef.paths[path].hasOwnProperty('parameters')) {
+        joinedDef.paths[path].parameters = [];
+      }
+
+      for (const parameter of pathItem.parameters as Oas3Parameter[]) {
+        let isFoundParameter = false;
+        for (const pathParameter of joinedDef.paths[path].parameters) {
+          if (pathParameter.name === parameter.name && pathParameter.in === parameter.in) {
+            if (!isEqual(pathParameter.schema, parameter.schema)) {
+              exitWithError(`Different parameter schemas for (${parameter.name}) in ${path}`);
+            }
+            isFoundParameter = true;
+          }
+        }
+
+        if (!isFoundParameter) {
+          joinedDef.paths[path].parameters.push(parameter);
+        }
+      }
+    }
+
+    function collectPathOperation(
+      pathItem: Oas3PathItem,
+      path: string | number,
+      operation: OPENAPI3_METHOD
+    ) {
+      const pathOperation = pathItem[operation];
+
+      if (!pathOperation) {
+        return;
+      }
+
+      joinedDef.paths[path][operation] = pathOperation;
+      potentialConflicts.paths[path][operation] = [
+        ...(potentialConflicts.paths[path][operation] || []),
+        api,
+      ];
+
+      const { operationId } = pathOperation;
+
+      if (operationId) {
+        if (!potentialConflicts.paths.hasOwnProperty('operationIds')) {
+          potentialConflicts.paths['operationIds'] = {};
+        }
+        potentialConflicts.paths.operationIds[operationId] = [
+          ...(potentialConflicts.paths.operationIds[operationId] || []),
+          api,
+        ];
+      }
+
+      const { tags, security } = joinedDef.paths[path][operation];
+
+      if (tags) {
+        joinedDef.paths[path][operation].tags = tags.map((tag: string) =>
+          addPrefix(tag, tagsPrefix)
+        );
+        populateTags({
+          api,
+          apiFilename,
+          tags: formatTags(tags),
+          potentialConflicts,
+          tagsPrefix,
+          componentsPrefix,
+        });
+      } else {
+        joinedDef.paths[path][operation]['tags'] = [addPrefix('other', tagsPrefix || apiFilename)];
+        populateTags({
+          api,
+          apiFilename,
+          tags: formatTags(['other']),
+          potentialConflicts,
+          tagsPrefix: tagsPrefix || apiFilename,
+          componentsPrefix,
+        });
+      }
+      if (!security && openapi.hasOwnProperty('security')) {
+        joinedDef.paths[path][operation]['security'] = addSecurityPrefix(
+          openapi.security,
+          componentsPrefix!
+        );
+      } else if (pathOperation.security) {
+        joinedDef.paths[path][operation].security = addSecurityPrefix(
+          pathOperation.security,
+          componentsPrefix!
+        );
+      }
+    }
+  }
+
+  function isServersEqual(serverOne: Oas3Server, serverTwo: Oas3Server) {
+    if (serverOne.description === serverTwo.description) {
+      return isEqual(serverOne.variables, serverTwo.variables);
+    }
+
+    return false;
   }
 
   function collectComponents(

package/src/commands/lint.ts

@@ -127,6 +127,11 @@ function lintConfigCallback(argv: LintOptions, version: string) {
     return;
   }
 
+  if (argv.format === 'json') {
+    // we can't print config lint results as it will break json output
+    return;
+  }
+
   return async (config: RawConfig) => {
     const { 'max-problems': maxProblems, format } = argv;
     const configPath = findConfig(argv.config) || '';

package/src/commands/split/types.ts

@@ -38,26 +38,26 @@ export const WEBHOOKS = 'webhooks';
 export const xWEBHOOKS = 'x-webhooks';
 export const componentsPath = `#/${COMPONENTS}/`;
 
-enum OPENAPI3_METHOD {
-  Get = 'get',
-  Put = 'put',
-  Post = 'post',
-  Delete = 'delete',
-  Options = 'options',
-  Head = 'head',
-  Patch = 'patch',
-  Trace = 'trace',
+export enum OPENAPI3_METHOD {
+  get = 'get',
+  put = 'put',
+  post = 'post',
+  delete = 'delete',
+  options = 'options',
+  head = 'head',
+  patch = 'patch',
+  trace = 'trace',
 }
 
 export const OPENAPI3_METHOD_NAMES: OPENAPI3_METHOD[] = [
-  OPENAPI3_METHOD.Get,
-  OPENAPI3_METHOD.Put,
-  OPENAPI3_METHOD.Post,
-  OPENAPI3_METHOD.Delete,
-  OPENAPI3_METHOD.Options,
-  OPENAPI3_METHOD.Head,
-  OPENAPI3_METHOD.Patch,
-  OPENAPI3_METHOD.Trace,
+  OPENAPI3_METHOD.get,
+  OPENAPI3_METHOD.put,
+  OPENAPI3_METHOD.post,
+  OPENAPI3_METHOD.delete,
+  OPENAPI3_METHOD.options,
+  OPENAPI3_METHOD.head,
+  OPENAPI3_METHOD.patch,
+  OPENAPI3_METHOD.trace,
 ];
 
 export enum OPENAPI3_COMPONENT {

package/src/commands/stats.ts

@@ -90,7 +90,7 @@ export async function handleStats(argv: { config?: string; api?: string; format:
 
   const resolvedRefMap = await resolveDocument({
     rootDocument: document,
-    rootType: types.DefinitionRoot,
+    rootType: types.Root,
     externalRefResolver,
   });
 
@@ -107,7 +107,7 @@ export async function handleStats(argv: { config?: string; api?: string; format:
 
   walkDocument({
     document,
-    rootType: types.DefinitionRoot,
+    rootType: types.Root,
     normalizedVisitors: statsVisitor,
     resolvedRefMap,
     ctx,

package/src/index.ts

@@ -152,6 +152,7 @@ yargs
             'json',
             'checkstyle',
             'codeclimate',
+            'summary',
           ] as ReadonlyArray<OutputFormat>,
           default: 'codeframe' as OutputFormat,
         },

package/src/js-utils.ts

@@ -10,3 +10,8 @@ export function isEmptyObject(obj: any) {
 export function isString(str: string) {
   return Object.prototype.toString.call(str) === '[object String]';
 }
+
+export function keysOf<T>(obj: T) {
+  if (!obj) return [];
+  return Object.keys(obj) as (keyof T)[];
+}

package/src/utils.ts

@@ -107,6 +107,7 @@ export function dumpBundle(obj: any, format: BundleOutputFormat, dereference?: b
   } else {
     return stringifyYaml(obj, {
       noRefs: !dereference,
+      lineWidth: -1,
     });
   }
 }