@redocly/cli 1.0.0-beta.98 → 1.0.0-rc.1

package/lib/commands/join.js

@@ -17,23 +17,50 @@ const isEqual = require('lodash.isequal');
 const openapi_core_1 = require("@redocly/openapi-core");
 const utils_1 = require("../utils");
 const js_utils_1 = require("../js-utils");
+const types_1 = require("./split/types");
 const COMPONENTS = 'components';
+const Tags = 'tags';
+const xTagGroups = 'x-tagGroups';
 let potentialConflictsTotal = 0;
-function handleJoin(argv, packageVersion) {
+function handleJoin(argv, config, packageVersion) {
     return __awaiter(this, void 0, void 0, function* () {
         const startedAt = perf_hooks_1.performance.now();
-        if (argv.entrypoints.length < 2) {
-            return utils_1.exitWithError(`At least 2 entrypoints should be provided. \n\n`);
+        if (argv.apis.length < 2) {
+            return utils_1.exitWithError(`At least 2 apis should be provided. \n\n`);
         }
-        const config = yield openapi_core_1.loadConfig();
-        const entrypoints = yield utils_1.getFallbackEntryPointsOrExit(argv.entrypoints, config);
+        const { 'prefix-components-with-info-prop': prefixComponentsWithInfoProp, 'prefix-tags-with-filename': prefixTagsWithFilename, 'prefix-tags-with-info-prop': prefixTagsWithInfoProp, 'without-x-tag-groups': withoutXTagGroups, output: specFilename = 'openapi.yaml', } = argv;
+        const usedTagsOptions = [
+            prefixTagsWithFilename && 'prefix-tags-with-filename',
+            prefixTagsWithInfoProp && 'prefix-tags-with-info-prop',
+            withoutXTagGroups && 'without-x-tag-groups',
+        ].filter(Boolean);
+        if (usedTagsOptions.length > 1) {
+            return utils_1.exitWithError(`You use ${colorette_1.yellow(usedTagsOptions.join(', '))} together.\nPlease choose only one! \n\n`);
+        }
+        const apis = yield utils_1.getFallbackApisOrExit(argv.apis, config);
         const externalRefResolver = new openapi_core_1.BaseResolver(config.resolve);
-        const documents = yield Promise.all(entrypoints.map(({ path }) => externalRefResolver.resolveDocument(null, path, true)));
-        const bundleResults = yield Promise.all(documents.map(document => openapi_core_1.bundleDocument({
+        const documents = yield Promise.all(apis.map(({ path }) => externalRefResolver.resolveDocument(null, path, true)));
+        if (!argv.decorate) {
+            const decorators = new Set([
+                ...Object.keys(config.styleguide.decorators.oas3_0),
+                ...Object.keys(config.styleguide.decorators.oas3_1),
+                ...Object.keys(config.styleguide.decorators.oas2),
+            ]);
+            config.styleguide.skipDecorators(Array.from(decorators));
+        }
+        if (!argv.preprocess) {
+            const preprocessors = new Set([
+                ...Object.keys(config.styleguide.preprocessors.oas3_0),
+                ...Object.keys(config.styleguide.preprocessors.oas3_1),
+                ...Object.keys(config.styleguide.preprocessors.oas2),
+            ]);
+            config.styleguide.skipPreprocessors(Array.from(preprocessors));
+        }
+        const bundleResults = yield Promise.all(documents.map((document) => openapi_core_1.bundleDocument({
             document,
-            config: config.lint,
-            externalRefResolver
-        }).catch(e => {
+            config: config.styleguide,
+            externalRefResolver,
+        }).catch((e) => {
             utils_1.exitWithError(`${e.message}: ${colorette_1.blue(document.source.absoluteRef)}`);
         })));
         for (const { problems, bundle: document } of bundleResults) {
@@ -41,7 +68,7 @@ function handleJoin(argv, packageVersion) {
             if (fileTotals.errors) {
                 openapi_core_1.formatProblems(problems, {
                     totals: fileTotals,
-                    version: document.parsed.version
+                    version: document.parsed.version,
                 });
                 utils_1.exitWithError(`❌ Errors encountered while bundling ${colorette_1.blue(document.source.absoluteRef)}: join will not proceed.\n`);
             }
@@ -59,34 +86,37 @@ function handleJoin(argv, packageVersion) {
         }
         if (argv.lint) {
             for (const document of documents) {
-                yield validateEntrypoint(document, config.lint, externalRefResolver, packageVersion);
+                yield validateApi(document, config.styleguide, externalRefResolver, packageVersion);
             }
         }
-        let joinedDef = {};
-        let potentialConflicts = {
+        const joinedDef = {};
+        const potentialConflicts = {
             tags: {},
             paths: {},
             components: {},
-            xWebhooks: {}
+            xWebhooks: {},
         };
-        const prefixComponentsWithInfoProp = argv['prefix-components-with-info-prop'];
-        const prefixTagsWithFilename = argv['prefix-tags-with-filename'];
-        const prefixTagsWithInfoProp = argv['prefix-tags-with-info-prop'];
-        if (prefixTagsWithFilename && prefixTagsWithInfoProp) {
-            return utils_1.exitWithError(`You used ${colorette_1.yellow('prefix-tags-with-filename')} and ${colorette_1.yellow('prefix-tags-with-info-prop')} that do not go together.\nPlease choose only one! \n\n`);
-        }
         addInfoSectionAndSpecVersion(documents, prefixComponentsWithInfoProp);
         for (const document of documents) {
             const openapi = document.parsed;
             const { tags, info } = openapi;
-            const entrypoint = path.relative(process.cwd(), document.source.absoluteRef);
-            const entrypointFilename = getEntrypointFilename(entrypoint);
-            const tagsPrefix = prefixTagsWithFilename ? entrypointFilename : getInfoPrefix(info, prefixTagsWithInfoProp, 'tags');
+            const api = path.relative(process.cwd(), document.source.absoluteRef);
+            const apiFilename = getApiFilename(api);
+            const tagsPrefix = prefixTagsWithFilename
+                ? apiFilename
+                : getInfoPrefix(info, prefixTagsWithInfoProp, 'tags');
             const componentsPrefix = getInfoPrefix(info, prefixComponentsWithInfoProp, COMPONENTS);
             if (openapi.hasOwnProperty('x-tagGroups')) {
-                process.stderr.write(colorette_1.yellow(`warning: x-tagGroups at ${colorette_1.blue(entrypoint)} will be skipped \n`));
+                process.stderr.write(colorette_1.yellow(`warning: x-tagGroups at ${colorette_1.blue(api)} will be skipped \n`));
             }
-            const context = { entrypoint, entrypointFilename, tags, potentialConflicts, tagsPrefix, componentsPrefix };
+            const context = {
+                api,
+                apiFilename,
+                tags,
+                potentialConflicts,
+                tagsPrefix,
+                componentsPrefix,
+            };
             if (tags) {
                 populateTags(context);
             }
@@ -100,52 +130,79 @@ function handleJoin(argv, packageVersion) {
                 replace$Refs(openapi, componentsPrefix);
             }
         }
-        iteratePotentialConflicts(potentialConflicts);
-        const specFilename = 'openapi.yaml';
+        iteratePotentialConflicts(potentialConflicts, withoutXTagGroups);
         const noRefs = true;
-        if (!potentialConflictsTotal) {
-            utils_1.writeYaml(joinedDef, specFilename, noRefs);
+        if (potentialConflictsTotal) {
+            return utils_1.exitWithError(`Please fix conflicts before running ${colorette_1.yellow('join')}.`);
         }
+        utils_1.writeYaml(utils_1.sortTopLevelKeysForOas(joinedDef), specFilename, noRefs);
         utils_1.printExecutionTime('join', startedAt, specFilename);
-        function populateTags({ entrypoint, entrypointFilename, tags, potentialConflicts, tagsPrefix, componentsPrefix }) {
-            const xTagGroups = 'x-tagGroups';
-            const Tags = 'tags';
+        function populateTags({ api, apiFilename, tags, potentialConflicts, tagsPrefix, componentsPrefix, }) {
             if (!joinedDef.hasOwnProperty(Tags)) {
                 joinedDef[Tags] = [];
             }
-            if (!joinedDef.hasOwnProperty(xTagGroups)) {
-                joinedDef[xTagGroups] = [];
-            }
             if (!potentialConflicts.tags.hasOwnProperty('all')) {
                 potentialConflicts.tags['all'] = {};
             }
-            if (!joinedDef[xTagGroups].some((g) => g.name === entrypointFilename)) {
-                joinedDef[xTagGroups].push({ name: entrypointFilename, tags: [] });
-            }
-            const indexGroup = joinedDef[xTagGroups].findIndex((item) => item.name === entrypointFilename);
-            if (!joinedDef[xTagGroups][indexGroup].hasOwnProperty(Tags)) {
-                joinedDef[xTagGroups][indexGroup][Tags] = [];
+            if (withoutXTagGroups && !potentialConflicts.tags.hasOwnProperty('description')) {
+                potentialConflicts.tags['description'] = {};
             }
             for (const tag of tags) {
                 const entrypointTagName = addPrefix(tag.name, tagsPrefix);
                 if (tag.description) {
                     tag.description = addComponentsPrefix(tag.description, componentsPrefix);
                 }
-                if (!joinedDef.tags.find((t) => t.name === entrypointTagName)) {
+                const tagDuplicate = joinedDef.tags.find((t) => t.name === entrypointTagName);
+                if (tagDuplicate && withoutXTagGroups) {
+                    // If tag already exist and `without-x-tag-groups` option,
+                    // check if description are different for potential conflicts warning.
+                    const isTagDescriptionNotEqual = tag.hasOwnProperty('description') && tagDuplicate.description !== tag.description;
+                    potentialConflicts.tags.description[entrypointTagName].push(...(isTagDescriptionNotEqual ? [api] : []));
+                }
+                else if (!tagDuplicate) {
+                    // Instead add tag to joinedDef if there no duplicate;
                     tag['x-displayName'] = tag['x-displayName'] || tag.name;
                     tag.name = entrypointTagName;
                     joinedDef.tags.push(tag);
+                    if (withoutXTagGroups) {
+                        potentialConflicts.tags.description[entrypointTagName] = [api];
+                    }
                 }
-                if (!joinedDef[xTagGroups][indexGroup][Tags].find((t) => t === entrypointTagName)) {
-                    joinedDef[xTagGroups][indexGroup][Tags].push(entrypointTagName);
+                if (!withoutXTagGroups) {
+                    createXTagGroups(apiFilename);
+                    if (!tagDuplicate) {
+                        populateXTagGroups(entrypointTagName, getIndexGroup(apiFilename));
+                    }
                 }
-                const doesEntrypointExist = !potentialConflicts.tags.all[entrypointTagName] || (potentialConflicts.tags.all[entrypointTagName] &&
-                    !potentialConflicts.tags.all[entrypointTagName].includes(entrypoint));
+                const doesEntrypointExist = !potentialConflicts.tags.all[entrypointTagName] ||
+                    (potentialConflicts.tags.all[entrypointTagName] &&
+                        !potentialConflicts.tags.all[entrypointTagName].includes(api));
                 potentialConflicts.tags.all[entrypointTagName] = [
-                    ...(potentialConflicts.tags.all[entrypointTagName] || []), ...(doesEntrypointExist ? [entrypoint] : [])
+                    ...(potentialConflicts.tags.all[entrypointTagName] || []),
+                    ...(!withoutXTagGroups && doesEntrypointExist ? [api] : []),
                 ];
             }
         }
+        function getIndexGroup(apiFilename) {
+            return joinedDef[xTagGroups].findIndex((item) => item.name === apiFilename);
+        }
+        function createXTagGroups(apiFilename) {
+            if (!joinedDef.hasOwnProperty(xTagGroups)) {
+                joinedDef[xTagGroups] = [];
+            }
+            if (!joinedDef[xTagGroups].some((g) => g.name === apiFilename)) {
+                joinedDef[xTagGroups].push({ name: apiFilename, tags: [] });
+            }
+            const indexGroup = getIndexGroup(apiFilename);
+            if (!joinedDef[xTagGroups][indexGroup].hasOwnProperty(Tags)) {
+                joinedDef[xTagGroups][indexGroup][Tags] = [];
+            }
+        }
+        function populateXTagGroups(entrypointTagName, indexGroup) {
+            if (!joinedDef[xTagGroups][indexGroup][Tags].find((t) => t.name === entrypointTagName)) {
+                joinedDef[xTagGroups][indexGroup][Tags].push(entrypointTagName);
+            }
+        }
         function collectServers(openapi) {
             const { servers } = openapi;
             if (servers) {
@@ -159,11 +216,10 @@ function handleJoin(argv, packageVersion) {
                 }
             }
         }
-        function collectInfoDescriptions(openapi, { entrypointFilename, componentsPrefix }) {
+        function collectInfoDescriptions(openapi, { apiFilename, componentsPrefix }) {
             const { info } = openapi;
             if (info === null || info === void 0 ? void 0 : info.description) {
-                const xTagGroups = 'x-tagGroups';
-                const groupIndex = joinedDef[xTagGroups] ? joinedDef[xTagGroups].findIndex((item) => item.name === entrypointFilename) : -1;
+                const groupIndex = joinedDef[xTagGroups] ? getIndexGroup(apiFilename) : -1;
                 if (joinedDef.hasOwnProperty(xTagGroups) &&
                     groupIndex !== -1 &&
                     joinedDef[xTagGroups][groupIndex]['tags'] &&
@@ -172,86 +228,191 @@ function handleJoin(argv, packageVersion) {
                 }
             }
         }
-        function collectExternalDocs(openapi, { entrypoint }) {
+        function collectExternalDocs(openapi, { api }) {
             const { externalDocs } = openapi;
             if (externalDocs) {
                 if (joinedDef.hasOwnProperty('externalDocs')) {
-                    process.stderr.write(colorette_1.yellow(`warning: skip externalDocs from ${colorette_1.blue(path.basename(entrypoint))} \n`));
+                    process.stderr.write(colorette_1.yellow(`warning: skip externalDocs from ${colorette_1.blue(path.basename(api))} \n`));
                     return;
                 }
                 joinedDef['externalDocs'] = externalDocs;
             }
         }
-        function collectPaths(openapi, { entrypointFilename, entrypoint, potentialConflicts, tagsPrefix, componentsPrefix }) {
+        function collectPaths(openapi, { apiFilename, api, potentialConflicts, tagsPrefix, componentsPrefix }) {
             const { paths } = openapi;
+            const operationsSet = new Set(js_utils_1.keysOf(types_1.OPENAPI3_METHOD));
             if (paths) {
                 if (!joinedDef.hasOwnProperty('paths')) {
                     joinedDef['paths'] = {};
                 }
-                for (const path of Object.keys(paths)) {
+                for (const path of js_utils_1.keysOf(paths)) {
                     if (!joinedDef.paths.hasOwnProperty(path)) {
                         joinedDef.paths[path] = {};
                     }
                     if (!potentialConflicts.paths.hasOwnProperty(path)) {
                         potentialConflicts.paths[path] = {};
                     }
-                    for (const operation of Object.keys(paths[path])) {
-                        // @ts-ignore
-                        const pathOperation = paths[path][operation];
-                        joinedDef.paths[path][operation] = pathOperation;
-                        potentialConflicts.paths[path][operation] = [...(potentialConflicts.paths[path][operation] || []), entrypoint];
-                        const { operationId } = pathOperation;
-                        if (operationId) {
-                            if (!potentialConflicts.paths.hasOwnProperty('operationIds')) {
-                                potentialConflicts.paths['operationIds'] = {};
-                            }
-                            potentialConflicts.paths.operationIds[operationId] = [...(potentialConflicts.paths.operationIds[operationId] || []), entrypoint];
+                    const pathItem = paths[path];
+                    for (const field of js_utils_1.keysOf(pathItem)) {
+                        if (operationsSet.has(field)) {
+                            collectPathOperation(pathItem, path, field);
                         }
-                        let { tags, security } = joinedDef.paths[path][operation];
-                        if (tags) {
-                            joinedDef.paths[path][operation].tags = tags.map((tag) => addPrefix(tag, tagsPrefix));
-                            populateTags({ entrypoint, entrypointFilename, tags: formatTags(tags), potentialConflicts, tagsPrefix, componentsPrefix });
+                        if (field === 'servers') {
+                            collectPathServers(pathItem, path);
                         }
-                        else {
-                            joinedDef.paths[path][operation]['tags'] = [addPrefix('other', tagsPrefix || entrypointFilename)];
-                            populateTags({ entrypoint, entrypointFilename, tags: formatTags(['other']), potentialConflicts, tagsPrefix: tagsPrefix || entrypointFilename, componentsPrefix });
+                        if (field === 'parameters') {
+                            collectPathParameters(pathItem, path);
                         }
-                        if (!security && openapi.hasOwnProperty('security')) {
-                            joinedDef.paths[path][operation]['security'] = addSecurityPrefix(openapi.security, componentsPrefix);
+                        if (typeof pathItem[field] === 'string') {
+                            collectPathStringFields(pathItem, path, field);
                         }
-                        else if (pathOperation.security) {
-                            joinedDef.paths[path][operation].security = addSecurityPrefix(pathOperation.security, componentsPrefix);
+                    }
+                }
+            }
+            function collectPathStringFields(pathItem, path, field) {
+                const fieldValue = pathItem[field];
+                if (joinedDef.paths[path].hasOwnProperty(field) &&
+                    joinedDef.paths[path][field] !== fieldValue) {
+                    process.stderr.write(colorette_1.yellow(`warning: different ${field} values in ${path}\n`));
+                    return;
+                }
+                joinedDef.paths[path][field] = fieldValue;
+            }
+            function collectPathServers(pathItem, path) {
+                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)) {
+                                utils_1.exitWithError(`Different server values for (${server.url}) in ${path}`);
+                            }
+                            isFoundServer = true;
                         }
                     }
+                    if (!isFoundServer) {
+                        joinedDef.paths[path].servers.push(server);
+                    }
+                }
+            }
+            function collectPathParameters(pathItem, path) {
+                if (!pathItem.parameters) {
+                    return;
+                }
+                if (!joinedDef.paths[path].hasOwnProperty('parameters')) {
+                    joinedDef.paths[path].parameters = [];
+                }
+                for (const parameter of pathItem.parameters) {
+                    let isFoundParameter = false;
+                    for (const pathParameter of joinedDef.paths[path]
+                        .parameters) {
+                        // Compare $ref only if both are reference objects
+                        if (openapi_core_1.isRef(pathParameter) && openapi_core_1.isRef(parameter)) {
+                            if (pathParameter['$ref'] === parameter['$ref']) {
+                                isFoundParameter = true;
+                            }
+                        }
+                        // Compare properties only if both are reference objects
+                        if (!openapi_core_1.isRef(pathParameter) && !openapi_core_1.isRef(parameter)) {
+                            if (pathParameter.name === parameter.name && pathParameter.in === parameter.in) {
+                                if (!isEqual(pathParameter.schema, parameter.schema)) {
+                                    utils_1.exitWithError(`Different parameter schemas for (${parameter.name}) in ${path}`);
+                                }
+                                isFoundParameter = true;
+                            }
+                        }
+                    }
+                    if (!isFoundParameter) {
+                        joinedDef.paths[path].parameters.push(parameter);
+                    }
+                }
+            }
+            function collectPathOperation(pathItem, path, operation) {
+                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) => 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 collectComponents(openapi, { entrypoint, potentialConflicts, componentsPrefix }) {
+        function isServersEqual(serverOne, serverTwo) {
+            if (serverOne.description === serverTwo.description) {
+                return isEqual(serverOne.variables, serverTwo.variables);
+            }
+            return false;
+        }
+        function collectComponents(openapi, { api, potentialConflicts, componentsPrefix }) {
             const { components } = openapi;
             if (components) {
                 if (!joinedDef.hasOwnProperty(COMPONENTS)) {
                     joinedDef[COMPONENTS] = {};
                 }
-                for (const component of Object.keys(components)) {
+                for (const [component, componentObj] of Object.entries(components)) {
                     if (!potentialConflicts[COMPONENTS].hasOwnProperty(component)) {
                         potentialConflicts[COMPONENTS][component] = {};
                         joinedDef[COMPONENTS][component] = {};
                     }
-                    // @ts-ignore
-                    const componentObj = components[component];
                     for (const item of Object.keys(componentObj)) {
                         const componentPrefix = addPrefix(item, componentsPrefix);
                         potentialConflicts.components[component][componentPrefix] = [
-                            ...(potentialConflicts.components[component][item] || []), { [entrypoint]: componentObj[item] }
+                            ...(potentialConflicts.components[component][item] || []),
+                            { [api]: componentObj[item] },
                         ];
                         joinedDef.components[component][componentPrefix] = componentObj[item];
                     }
                 }
             }
         }
-        function collectXWebhooks(openapi, { entrypointFilename, entrypoint, potentialConflicts, tagsPrefix, componentsPrefix }) {
+        function collectXWebhooks(openapi, { apiFilename, api, potentialConflicts, tagsPrefix, componentsPrefix }) {
             const xWebhooks = 'x-webhooks';
-            // @ts-ignore
             const openapiXWebhooks = openapi[xWebhooks];
             if (openapiXWebhooks) {
                 if (!joinedDef.hasOwnProperty(xWebhooks)) {
@@ -263,13 +424,23 @@ function handleJoin(argv, packageVersion) {
                         potentialConflicts.xWebhooks[webhook] = {};
                     }
                     for (const operation of Object.keys(openapiXWebhooks[webhook])) {
-                        potentialConflicts.xWebhooks[webhook][operation] = [...(potentialConflicts.xWebhooks[webhook][operation] || []), entrypoint];
+                        potentialConflicts.xWebhooks[webhook][operation] = [
+                            ...(potentialConflicts.xWebhooks[webhook][operation] || []),
+                            api,
+                        ];
                     }
                     for (const operationKey of Object.keys(joinedDef[xWebhooks][webhook])) {
-                        let { tags } = joinedDef[xWebhooks][webhook][operationKey];
+                        const { tags } = joinedDef[xWebhooks][webhook][operationKey];
                         if (tags) {
                             joinedDef[xWebhooks][webhook][operationKey].tags = tags.map((tag) => addPrefix(tag, tagsPrefix));
-                            populateTags({ entrypoint, entrypointFilename, tags: formatTags(tags), potentialConflicts, tagsPrefix, componentsPrefix });
+                            populateTags({
+                                api,
+                                apiFilename,
+                                tags: formatTags(tags),
+                                potentialConflicts,
+                                tagsPrefix,
+                                componentsPrefix,
+                            });
                         }
                     }
                 }
@@ -277,8 +448,8 @@ function handleJoin(argv, packageVersion) {
         }
         function addInfoSectionAndSpecVersion(documents, prefixComponentsWithInfoProp) {
             var _a;
-            const firstEntrypoint = documents[0];
-            const openapi = firstEntrypoint.parsed;
+            const firstApi = documents[0];
+            const openapi = firstApi.parsed;
             const componentsPrefix = getInfoPrefix(openapi.info, prefixComponentsWithInfoProp, COMPONENTS);
             if (!openapi.openapi)
                 utils_1.exitWithError('Version of specification is not found in. \n');
@@ -299,14 +470,14 @@ function doesComponentsDiffer(curr, next) {
 function validateComponentsDifference(files) {
     let isDiffer = false;
     for (let i = 0, len = files.length; i < len; i++) {
-        let next = files[i + 1];
+        const next = files[i + 1];
         if (next && doesComponentsDiffer(files[i], next)) {
             isDiffer = true;
         }
     }
     return isDiffer;
 }
-function iteratePotentialConflicts(potentialConflicts) {
+function iteratePotentialConflicts(potentialConflicts, withoutXTagGroups) {
     for (const group of Object.keys(potentialConflicts)) {
         for (const [key, value] of Object.entries(potentialConflicts[group])) {
             const conflicts = filterConflicts(value);
@@ -321,20 +492,28 @@ function iteratePotentialConflicts(potentialConflicts) {
                     }
                 }
                 else {
-                    showConflicts(colorette_1.green(group) + ' => ' + key, conflicts);
-                    potentialConflictsTotal += conflicts.length;
+                    if (withoutXTagGroups && group === 'tags') {
+                        duplicateTagDescriptionWarning(conflicts);
+                    }
+                    else {
+                        potentialConflictsTotal += conflicts.length;
+                        showConflicts(colorette_1.green(group) + ' => ' + key, conflicts);
+                    }
+                }
+                if (group === 'tags' && !withoutXTagGroups) {
+                    prefixTagSuggestion(conflicts.length);
                 }
-                prefixTagSuggestion(group, conflicts.length);
             }
         }
     }
 }
-function prefixTagSuggestion(group, conflictsLength) {
-    if (group === 'tags') {
-        process.stderr.write(colorette_1.green(`
-    ${conflictsLength} conflict(s) on tags.
-    Suggestion: please use ${colorette_1.blue('prefix-tags-with-filename')} or ${colorette_1.blue('prefix-tags-with-info-prop')} to prevent naming conflicts. \n\n`));
-    }
+function duplicateTagDescriptionWarning(conflicts) {
+    const tagsKeys = conflicts.map(([tagName]) => `\`${tagName}\``);
+    const joinString = colorette_1.yellow(', ');
+    process.stderr.write(colorette_1.yellow(`\nwarning: ${tagsKeys.length} conflict(s) on the ${colorette_1.red(tagsKeys.join(joinString))} tags description.\n`));
+}
+function prefixTagSuggestion(conflictsLength) {
+    process.stderr.write(colorette_1.green(`\n${conflictsLength} conflict(s) on tags.\nSuggestion: please use ${colorette_1.blue('prefix-tags-with-filename')}, ${colorette_1.blue('prefix-tags-with-info-prop')} or ${colorette_1.blue('without-x-tag-groups')} to prevent naming conflicts.\n\n`));
 }
 function showConflicts(key, conflicts) {
     for (const [path, files] of conflicts) {
@@ -344,7 +523,7 @@ function showConflicts(key, conflicts) {
 function filterConflicts(entities) {
     return Object.entries(entities).filter(([_, files]) => files.length > 1);
 }
-function getEntrypointFilename(filePath) {
+function getApiFilename(filePath) {
     return path.basename(filePath, path.extname(filePath));
 }
 function addPrefix(tag, tagsPrefix) {
@@ -360,10 +539,12 @@ function addComponentsPrefix(description, componentsPrefix) {
     });
 }
 function addSecurityPrefix(security, componentsPrefix) {
-    return componentsPrefix ? security === null || security === void 0 ? void 0 : security.map((s) => {
-        const key = Object.keys(s)[0];
-        return { [componentsPrefix + '_' + key]: s[key] };
-    }) : security;
+    return componentsPrefix
+        ? security === null || security === void 0 ? void 0 : security.map((s) => {
+            const key = Object.keys(s)[0];
+            return { [componentsPrefix + '_' + key]: s[key] };
+        })
+        : security;
 }
 function getInfoPrefix(info, prefixArg, type) {
     if (!prefixArg)
@@ -378,7 +559,7 @@ function getInfoPrefix(info, prefixArg, type) {
         utils_1.exitWithError(`${colorette_1.yellow(`prefix-${type}-with-info-prop`)} argument value length should not exceed 50 characters. \n\n`);
     return info[prefixArg];
 }
-function validateEntrypoint(document, config, externalRefResolver, packageVersion) {
+function validateApi(document, config, externalRefResolver, packageVersion) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const results = yield openapi_core_1.lintDocument({ document, config, externalRefResolver });
@@ -411,9 +592,14 @@ function replace$Refs(obj, componentsPrefix) {
             const { mapping } = node.discriminator;
             for (const name of Object.keys(mapping)) {
                 if (js_utils_1.isString(mapping[name]) && mapping[name].startsWith(`#/${COMPONENTS}/`)) {
-                    mapping[name] = mapping[name].split('/').map((name, i, arr) => {
-                        return (arr.length - 1 === i && !name.includes(componentsPrefix)) ? componentsPrefix + '_' + name : name;
-                    }).join('/');
+                    mapping[name] = mapping[name]
+                        .split('/')
+                        .map((name, i, arr) => {
+                        return arr.length - 1 === i && !name.includes(componentsPrefix)
+                            ? componentsPrefix + '_' + name
+                            : name;
+                    })
+                        .join('/');
                 }
             }
         }

package/lib/commands/lint.d.ts

@@ -1,11 +1,14 @@
-import { OutputFormat } from '@redocly/openapi-core';
-export declare function handleLint(argv: {
-    entrypoints: string[];
-    'max-problems'?: number;
-    'generate-ignore-file'?: boolean;
-    'skip-rule'?: string[];
-    'skip-preprocessor'?: string[];
+import { Config } from '@redocly/openapi-core';
+import type { OutputFormat, RawConfig, RuleSeverity } from '@redocly/openapi-core';
+import type { CommandOptions, Skips } from '../types';
+export declare type LintOptions = {
+    apis?: string[];
+    'max-problems': number;
     extends?: string[];
     config?: string;
     format: OutputFormat;
-}, version: string): Promise<void>;
+    'generate-ignore-file'?: boolean;
+    'lint-config'?: RuleSeverity;
+} & Omit<Skips, 'skip-decorator'>;
+export declare function handleLint(argv: LintOptions, config: Config, version: string): Promise<void>;
+export declare function lintConfigCallback(argv: CommandOptions & Record<string, undefined>, version: string): ((config: RawConfig) => Promise<void>) | undefined;