@redocly/cli 1.10.6 → 1.12.0

package/lib/cms/commands/push-status.js

@@ -14,10 +14,10 @@ const colors = require("colorette");
 const miscellaneous_1 = require("../../utils/miscellaneous");
 const spinner_1 = require("../../utils/spinner");
 const utils_1 = require("../utils");
-const colorette_1 = require("colorette");
 const api_1 = require("../api");
 const js_utils_1 = require("../../utils/js-utils");
-const INTERVAL = 5000;
+const utils_2 = require("./utils");
+const RETRY_INTERVAL_MS = 5000; // 5 sec
 function handlePushStatus(argv, config) {
     return __awaiter(this, void 0, void 0, function* () {
         const startedAt = performance.now();
@@ -25,97 +25,154 @@ function handlePushStatus(argv, config) {
         const { organization, project: projectId, pushId, wait } = argv;
         const orgId = organization || config.organization;
         if (!orgId) {
-            return (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+            (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+            return;
         }
         const domain = argv.domain || (0, api_1.getDomain)();
-        if (!domain) {
-            return (0, miscellaneous_1.exitWithError)(`No domain provided, please use --domain option or environment variable REDOCLY_DOMAIN.`);
-        }
-        const maxExecutionTime = argv['max-execution-time'] || 600;
+        const maxExecutionTime = argv['max-execution-time'] || 1200; // 20 min
+        const retryIntervalMs = argv['retry-interval']
+            ? argv['retry-interval'] * 1000
+            : RETRY_INTERVAL_MS;
+        const startTime = argv['start-time'] || Date.now();
+        const retryTimeoutMs = maxExecutionTime * 1000;
+        const continueOnDeployFailures = argv['continue-on-deploy-failures'] || false;
         try {
             const apiKey = (0, api_1.getApiKeys)(domain);
             const client = new api_1.ReuniteApiClient(domain, apiKey);
-            if (wait) {
-                const push = yield waitForDeployment(client, 'preview');
-                if (push.isMainBranch && push.status.preview.deploy.status === 'success') {
-                    yield waitForDeployment(client, 'production');
-                }
-                printPushStatusInfo();
-                return;
+            let pushResponse;
+            pushResponse = yield (0, utils_2.retryUntilConditionMet)({
+                operation: () => client.remotes.getPush({
+                    organizationId: orgId,
+                    projectId,
+                    pushId,
+                }),
+                condition: wait
+                    ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
+                        (result) => !['pending', 'running'].includes(result.status['preview'].deploy.status)
+                    : null,
+                onConditionNotMet: (lastResult) => {
+                    displayDeploymentAndBuildStatus({
+                        status: lastResult.status['preview'].deploy.status,
+                        url: lastResult.status['preview'].deploy.url,
+                        spinner,
+                        buildType: 'preview',
+                        continueOnDeployFailures,
+                        wait,
+                    });
+                },
+                onRetry: (lastResult) => {
+                    if (argv.onRetry) {
+                        argv.onRetry({
+                            preview: lastResult.status.preview,
+                            production: lastResult.isMainBranch ? lastResult.status.production : null,
+                            commit: lastResult.commit,
+                        });
+                    }
+                },
+                startTime,
+                retryTimeoutMs,
+                retryIntervalMs,
+            });
+            printPushStatus({
+                buildType: 'preview',
+                spinner,
+                wait,
+                push: pushResponse,
+                continueOnDeployFailures,
+            });
+            printScorecard(pushResponse.status.preview.scorecard);
+            const shouldWaitForProdDeployment = pushResponse.isMainBranch &&
+                (wait ? pushResponse.status.preview.deploy.status === 'success' : true);
+            if (shouldWaitForProdDeployment) {
+                pushResponse = yield (0, utils_2.retryUntilConditionMet)({
+                    operation: () => client.remotes.getPush({
+                        organizationId: orgId,
+                        projectId,
+                        pushId,
+                    }),
+                    condition: wait
+                        ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
+                            (result) => !['pending', 'running'].includes(result.status['production'].deploy.status)
+                        : null,
+                    onConditionNotMet: (lastResult) => {
+                        displayDeploymentAndBuildStatus({
+                            status: lastResult.status['production'].deploy.status,
+                            url: lastResult.status['production'].deploy.url,
+                            spinner,
+                            buildType: 'production',
+                            continueOnDeployFailures,
+                            wait,
+                        });
+                    },
+                    onRetry: (lastResult) => {
+                        if (argv.onRetry) {
+                            argv.onRetry({
+                                preview: lastResult.status.preview,
+                                production: lastResult.isMainBranch ? lastResult.status.production : null,
+                                commit: lastResult.commit,
+                            });
+                        }
+                    },
+                    startTime,
+                    retryTimeoutMs,
+                    retryIntervalMs,
+                });
             }
-            const pushPreview = yield getAndPrintPushStatus(client, 'preview');
-            printScorecard(pushPreview.status.preview.scorecard);
-            if (pushPreview.isMainBranch) {
-                yield getAndPrintPushStatus(client, 'production');
-                printScorecard(pushPreview.status.production.scorecard);
+            if (pushResponse.isMainBranch) {
+                printPushStatus({
+                    buildType: 'production',
+                    spinner,
+                    wait,
+                    push: pushResponse,
+                    continueOnDeployFailures,
+                });
+                printScorecard(pushResponse.status.production.scorecard);
             }
-            printPushStatusInfo();
+            printPushStatusInfo({ orgId, projectId, pushId, startedAt });
+            const summary = {
+                preview: pushResponse.status.preview,
+                production: pushResponse.isMainBranch ? pushResponse.status.production : null,
+                commit: pushResponse.commit,
+            };
+            return summary;
         }
         catch (err) {
+            spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
             const message = err instanceof utils_1.DeploymentError
                 ? err.message
                 : `✗ Failed to get push status. Reason: ${err.message}\n`;
             (0, miscellaneous_1.exitWithError)(message);
+            return;
         }
-        function printPushStatusInfo() {
-            process.stderr.write(`\nProcessed push-status for ${colors.yellow(orgId)}, ${colors.yellow(projectId)} and pushID ${colors.yellow(pushId)}.\n`);
-            (0, miscellaneous_1.printExecutionTime)('push-status', startedAt, 'Finished');
-        }
-        function waitForDeployment(client, buildType) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return new Promise((resolve, reject) => {
-                    if (performance.now() - startedAt > maxExecutionTime * 1000) {
-                        spinner.stop();
-                        reject(new Error(`Time limit exceeded.`));
-                    }
-                    getAndPrintPushStatus(client, buildType)
-                        .then((push) => {
-                        if (!['pending', 'running'].includes(push.status[buildType].deploy.status)) {
-                            printScorecard(push.status[buildType].scorecard);
-                            resolve(push);
-                            return;
-                        }
-                        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                            try {
-                                const pushResponse = yield waitForDeployment(client, buildType);
-                                resolve(pushResponse);
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        }), INTERVAL);
-                    })
-                        .catch(reject);
-                });
-            });
-        }
-        function getAndPrintPushStatus(client, buildType) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const push = yield client.remotes.getPush({
-                    organizationId: orgId,
-                    projectId,
-                    pushId,
-                });
-                if (push.isOutdated || !push.hasChanges) {
-                    process.stderr.write((0, colorette_1.yellow)(`Files not uploaded. Reason: ${push.isOutdated ? 'outdated' : 'no changes'}.\n`));
-                }
-                else {
-                    displayDeploymentAndBuildStatus({
-                        status: push.status[buildType].deploy.status,
-                        previewUrl: push.status[buildType].deploy.url,
-                        buildType,
-                        spinner,
-                        wait,
-                    });
-                }
-                return push;
-            });
+        finally {
+            spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
         }
     });
 }
 exports.handlePushStatus = handlePushStatus;
+function printPushStatusInfo({ orgId, projectId, pushId, startedAt, }) {
+    process.stderr.write(`\nProcessed push-status for ${colors.yellow(orgId)}, ${colors.yellow(projectId)} and pushID ${colors.yellow(pushId)}.\n`);
+    (0, miscellaneous_1.printExecutionTime)('push-status', startedAt, 'Finished');
+}
+function printPushStatus({ buildType, spinner, push, continueOnDeployFailures, }) {
+    if (!push) {
+        return;
+    }
+    if (push.isOutdated || !push.hasChanges) {
+        process.stderr.write(colors.yellow(`Files not added to your project. Reason: ${push.isOutdated ? 'outdated' : 'no changes'}.\n`));
+    }
+    else {
+        displayDeploymentAndBuildStatus({
+            status: push.status[buildType].deploy.status,
+            url: push.status[buildType].deploy.url,
+            buildType,
+            spinner,
+            continueOnDeployFailures,
+        });
+    }
+}
 function printScorecard(scorecard) {
-    if (!scorecard.length) {
+    if (!scorecard || scorecard.length === 0) {
         return;
     }
     process.stdout.write(`\n${colors.magenta('Scorecard')}:`);
@@ -128,24 +185,37 @@ function printScorecard(scorecard) {
     }
     process.stdout.write(`\n`);
 }
-function displayDeploymentAndBuildStatus({ status, previewUrl, spinner, buildType, wait, }) {
+function displayDeploymentAndBuildStatus({ status, url, spinner, buildType, continueOnDeployFailures, wait, }) {
+    const message = getMessage({ status, url, buildType, wait });
+    if (status === 'failed' && !continueOnDeployFailures) {
+        spinner.stop();
+        throw new utils_1.DeploymentError(message);
+    }
+    if (wait && (status === 'pending' || status === 'running')) {
+        return spinner.start(message);
+    }
+    spinner.stop();
+    return process.stdout.write(message);
+}
+function getMessage({ status, url, buildType, wait, }) {
     switch (status) {
+        case 'skipped':
+            return `${colors.yellow(`Skipped ${buildType}`)}\n`;
+        case 'pending': {
+            const message = `${colors.yellow(`Pending ${buildType}`)}`;
+            return wait ? message : `Status: ${message}\n`;
+        }
+        case 'running': {
+            const message = `${colors.yellow(`Running ${buildType}`)}`;
+            return wait ? message : `Status: ${message}\n`;
+        }
         case 'success':
-            spinner.stop();
-            return process.stdout.write(`${colors.green(`🚀 ${(0, js_utils_1.capitalize)(buildType)} deploy success.`)}\n${colors.magenta(`${(0, js_utils_1.capitalize)(buildType)} URL`)}: ${colors.cyan(previewUrl)}\n`);
+            return `${colors.green(`🚀 ${(0, js_utils_1.capitalize)(buildType)} deploy success.`)}\n${colors.magenta(`${(0, js_utils_1.capitalize)(buildType)} URL`)}: ${colors.cyan(url || 'No URL yet.')}\n`;
         case 'failed':
-            spinner.stop();
-            throw new utils_1.DeploymentError(`${colors.red(`❌ ${(0, js_utils_1.capitalize)(buildType)} deploy fail.`)}\n${colors.magenta(`${(0, js_utils_1.capitalize)(buildType)} URL`)}: ${colors.cyan(previewUrl)}`);
-        case 'pending':
-            return wait
-                ? spinner.start(`${colors.yellow(`Pending ${buildType}`)}`)
-                : process.stdout.write(`Status: ${colors.yellow(`Pending ${buildType}`)}\n`);
-        case 'skipped':
-            spinner.stop();
-            return process.stdout.write(`${colors.yellow(`Skipped ${buildType}`)}\n`);
-        case 'running':
-            return wait
-                ? spinner.start(`${colors.yellow(`Running ${buildType}`)}`)
-                : process.stdout.write(`Status: ${colors.yellow(`Running ${buildType}`)}\n`);
+            return `${colors.red(`❌ ${(0, js_utils_1.capitalize)(buildType)} deploy fail.`)}\n${colors.magenta(`${(0, js_utils_1.capitalize)(buildType)} URL`)}: ${colors.cyan(url || 'No URL yet.')}`;
+        default: {
+            const message = `${colors.yellow(`No status yet for ${buildType} deploy`)}`;
+            return wait ? message : `Status: ${message}\n`;
+        }
     }
 }

package/lib/cms/commands/push.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '@redocly/openapi-core';
+import type { OutputFormat, Config } from '@redocly/openapi-core';
 export type PushOptions = {
     apis?: string[];
     organization?: string;
@@ -18,6 +18,10 @@ export type PushOptions = {
     config?: string;
     'wait-for-deployment'?: boolean;
     'max-execution-time': number;
+    'continue-on-deploy-failures'?: boolean;
     verbose?: boolean;
+    format?: Extract<OutputFormat, 'stylish'>;
 };
-export declare function handlePush(argv: PushOptions, config: Config): Promise<void>;
+export declare function handlePush(argv: PushOptions, config: Config): Promise<{
+    pushId: string;
+} | void>;

package/lib/cms/commands/push.js

@@ -13,14 +13,15 @@ exports.handlePush = void 0;
 const fs = require("fs");
 const path = require("path");
 const openapi_core_1 = require("@redocly/openapi-core");
-const miscellaneous_1 = require("../../utils/miscellaneous");
 const colorette_1 = require("colorette");
 const pluralize = require("pluralize");
+const miscellaneous_1 = require("../../utils/miscellaneous");
 const push_status_1 = require("./push-status");
 const api_1 = require("../api");
 function handlePush(argv, config) {
     return __awaiter(this, void 0, void 0, function* () {
-        const startedAt = performance.now();
+        const startedAt = performance.now(); // for printing execution time
+        const startTime = Date.now(); // for push-status command
         const { organization, project: projectId, 'mount-path': mountPath, verbose } = argv;
         const orgId = organization || config.organization;
         if (!argv.message || !argv.author || !argv.branch) {
@@ -76,10 +77,15 @@ function handlePush(argv, config) {
                     wait: true,
                     domain,
                     'max-execution-time': maxExecutionTime,
+                    'start-time': startTime,
+                    'continue-on-deploy-failures': argv['continue-on-deploy-failures'],
                 }, config);
             }
             verbose &&
                 (0, miscellaneous_1.printExecutionTime)('push', startedAt, `${pluralize('file', filesToUpload.length)} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`);
+            return {
+                pushId: id,
+            };
         }
         catch (err) {
             const message = err instanceof miscellaneous_1.HandledError ? '' : `✗ File upload failed. Reason: ${err.message}`;

package/lib/cms/commands/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This function retries an operation until a condition is met or a timeout is exceeded.
+ * If the condition is not met within the timeout, an error is thrown.
+ * @operation The operation to retry.
+ * @condition The condition to check after each operation result. Return false to continue retrying. Return true to stop retrying.
+ *            If not provided, the first result will be returned.
+ * @param onConditionNotMet Will be called with the last result right after checking condition and before timeout and retrying.
+ * @param onRetry Will be called right before retrying operation with the last result before retrying.
+ * @param startTime The start time of the operation. Default is the current time.
+ * @param retryTimeoutMs The maximum time to retry the operation. Default is 10 minutes.
+ * @param retryIntervalMs The interval between retries. Default is 5 seconds.
+ */
+export declare function retryUntilConditionMet<T>({ operation, condition, onConditionNotMet, onRetry, startTime, retryTimeoutMs, // 10 min
+retryIntervalMs, }: {
+    operation: () => Promise<T>;
+    condition?: ((result: T) => boolean) | null;
+    onConditionNotMet?: (lastResult: T) => void;
+    onRetry?: (lastResult: T) => void | Promise<void>;
+    startTime?: number;
+    retryTimeoutMs?: number;
+    retryIntervalMs?: number;
+}): Promise<T>;

package/lib/cms/commands/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryUntilConditionMet = void 0;
+const openapi_core_1 = require("@redocly/openapi-core");
+/**
+ * This function retries an operation until a condition is met or a timeout is exceeded.
+ * If the condition is not met within the timeout, an error is thrown.
+ * @operation The operation to retry.
+ * @condition The condition to check after each operation result. Return false to continue retrying. Return true to stop retrying.
+ *            If not provided, the first result will be returned.
+ * @param onConditionNotMet Will be called with the last result right after checking condition and before timeout and retrying.
+ * @param onRetry Will be called right before retrying operation with the last result before retrying.
+ * @param startTime The start time of the operation. Default is the current time.
+ * @param retryTimeoutMs The maximum time to retry the operation. Default is 10 minutes.
+ * @param retryIntervalMs The interval between retries. Default is 5 seconds.
+ */
+function retryUntilConditionMet({ operation, condition, onConditionNotMet, onRetry, startTime = Date.now(), retryTimeoutMs = 600000, // 10 min
+retryIntervalMs = 5000, // 5 sec
+ }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        function attempt() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const result = yield operation();
+                if (!condition) {
+                    return result;
+                }
+                if (condition(result)) {
+                    return result;
+                }
+                else if (Date.now() - startTime > retryTimeoutMs) {
+                    throw new Error('Timeout exceeded');
+                }
+                else {
+                    onConditionNotMet === null || onConditionNotMet === void 0 ? void 0 : onConditionNotMet(result);
+                    yield (0, openapi_core_1.pause)(retryIntervalMs);
+                    yield (onRetry === null || onRetry === void 0 ? void 0 : onRetry(result));
+                    return attempt();
+                }
+            });
+        }
+        return attempt();
+    });
+}
+exports.retryUntilConditionMet = retryUntilConditionMet;

package/lib/commands/bundle.d.ts

@@ -1,16 +1,13 @@
-import { Config, OutputFormat } from '@redocly/openapi-core';
+import { Config } from '@redocly/openapi-core';
 import type { OutputExtensions, Skips } from '../types';
 export type BundleOptions = {
     apis?: string[];
-    'max-problems'?: number;
     extends?: string[];
     config?: string;
-    format?: OutputFormat;
     output?: string;
     ext: OutputExtensions;
     dereferenced?: boolean;
     force?: boolean;
-    lint?: boolean;
     metafile?: string;
     'remove-unused-components'?: boolean;
     'keep-url-references'?: boolean;

package/lib/commands/bundle.js

@@ -34,44 +34,15 @@ function handleBundle(argv, config, version) {
             ((_c = (_b = (_a = config.rawConfig) === null || _a === void 0 ? void 0 : _a.styleguide) === null || _b === void 0 ? void 0 : _b.decorators) === null || _c === void 0 ? void 0 : _c.hasOwnProperty('remove-unused-components'));
         const apis = yield (0, miscellaneous_1.getFallbackApisOrExit)(argv.apis, config);
         const totals = { errors: 0, warnings: 0, ignored: 0 };
-        const maxProblems = argv['max-problems'];
-        const deprecatedOptions = [
-            'lint',
-            'format',
-            'skip-rule',
-            'extends',
-            'max-problems',
-        ];
+        const deprecatedOptions = [];
         (0, miscellaneous_2.checkForDeprecatedOptions)(argv, deprecatedOptions);
         for (const { path, alias } of apis) {
             try {
                 const startedAt = perf_hooks_1.performance.now();
                 const resolvedConfig = (0, openapi_core_1.getMergedConfig)(config, alias);
                 const { styleguide } = resolvedConfig;
-                styleguide.skipRules(argv['skip-rule']);
                 styleguide.skipPreprocessors(argv['skip-preprocessor']);
                 styleguide.skipDecorators(argv['skip-decorator']);
-                if (argv.lint) {
-                    (0, miscellaneous_1.checkIfRulesetExist)(styleguide.rules);
-                    if (config.styleguide.recommendedFallback) {
-                        process.stderr.write(`No configurations were provided -- using built in ${(0, colorette_1.blue)('recommended')} configuration by default.\n\n`);
-                    }
-                    const results = yield (0, openapi_core_1.lint)({
-                        ref: path,
-                        config: resolvedConfig,
-                    });
-                    const fileLintTotals = (0, openapi_core_1.getTotals)(results);
-                    totals.errors += fileLintTotals.errors;
-                    totals.warnings += fileLintTotals.warnings;
-                    totals.ignored += fileLintTotals.ignored;
-                    (0, openapi_core_1.formatProblems)(results, {
-                        format: argv.format || 'codeframe',
-                        totals: fileLintTotals,
-                        version,
-                        maxProblems: maxProblems,
-                    });
-                    (0, miscellaneous_1.printLintTotals)(fileLintTotals, 2);
-                }
                 process.stderr.write((0, colorette_1.gray)(`bundling ${path}...\n`));
                 const _f = yield (0, openapi_core_1.bundle)({
                     config: resolvedConfig,
@@ -96,8 +67,7 @@ function handleBundle(argv, config, version) {
                 totals.warnings += fileTotals.warnings;
                 totals.ignored += fileTotals.ignored;
                 (0, openapi_core_1.formatProblems)(problems, {
-                    format: argv.format || 'codeframe',
-                    maxProblems: maxProblems,
+                    format: 'codeframe',
                     totals: fileTotals,
                     version,
                 });

package/lib/commands/join.d.ts

@@ -2,9 +2,6 @@ import { Config } from '@redocly/openapi-core';
 import type { RuleSeverity } from '@redocly/openapi-core';
 export type JoinOptions = {
     apis: string[];
-    lint?: boolean;
-    decorate?: boolean;
-    preprocess?: boolean;
     'prefix-tags-with-info-prop'?: string;
     'prefix-tags-with-filename'?: boolean;
     'prefix-components-with-info-prop'?: string;

package/lib/commands/join.js

@@ -28,7 +28,6 @@ function handleJoin(argv, config, packageVersion) {
         if (argv.apis.length < 2) {
             return (0, miscellaneous_1.exitWithError)(`At least 2 apis should be provided. \n\n`);
         }
-        (0, miscellaneous_1.checkForDeprecatedOptions)(argv, ['lint']);
         const fileExtension = (0, miscellaneous_1.getAndValidateFileExtension)(argv.output || argv.apis[0]);
         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.${fileExtension}`, } = argv;
         const usedTagsOptions = [
@@ -42,22 +41,18 @@ function handleJoin(argv, config, packageVersion) {
         const apis = yield (0, miscellaneous_1.getFallbackApisOrExit)(argv.apis, config);
         const externalRefResolver = new openapi_core_1.BaseResolver(config.resolve);
         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 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));
+        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) => (0, openapi_core_1.bundleDocument)({
             document,
             config: config.styleguide,
@@ -70,7 +65,7 @@ function handleJoin(argv, config, packageVersion) {
             if (fileTotals.errors) {
                 (0, openapi_core_1.formatProblems)(problems, {
                     totals: fileTotals,
-                    version: document.parsed.version,
+                    version: packageVersion,
                 });
                 (0, miscellaneous_1.exitWithError)(`❌ Errors encountered while bundling ${(0, colorette_1.blue)(document.source.absoluteRef)}: join will not proceed.\n`);
             }
@@ -91,11 +86,6 @@ function handleJoin(argv, config, packageVersion) {
                 return (0, miscellaneous_1.exitWithError)(`${e.message}: ${(0, colorette_1.blue)(document.source.absoluteRef)}`);
             }
         }
-        if (argv.lint) {
-            for (const document of documents) {
-                yield validateApi(document, config.styleguide, externalRefResolver, packageVersion);
-            }
-        }
         const joinedDef = {};
         const potentialConflicts = {
             tags: {},
@@ -561,19 +551,6 @@ function getInfoPrefix(info, prefixArg, type) {
         (0, miscellaneous_1.exitWithError)(`${(0, colorette_1.yellow)(`prefix-${type}-with-info-prop`)} argument value length should not exceed 50 characters. \n\n`);
     return info[prefixArg].replaceAll(/\s/g, '_');
 }
-function validateApi(document, config, externalRefResolver, packageVersion) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const results = yield (0, openapi_core_1.lintDocument)({ document, config, externalRefResolver });
-            const fileTotals = (0, openapi_core_1.getTotals)(results);
-            (0, openapi_core_1.formatProblems)(results, { format: 'stylish', totals: fileTotals, version: packageVersion });
-            (0, miscellaneous_1.printLintTotals)(fileTotals, 2);
-        }
-        catch (err) {
-            (0, miscellaneous_1.handleError)(err, document.parsed);
-        }
-    });
-}
 function replace$Refs(obj, componentsPrefix) {
     (0, split_1.crawl)(obj, (node) => {
         if (node.$ref && typeof node.$ref === 'string' && (0, split_1.startsWithComponents)(node.$ref)) {