@redocly/cli 1.0.0-beta.96

package/README.md

@@ -0,0 +1,39 @@
+# Redocly CLI toolset
+
+Redocly CLI toolbox with rich validation and bundling features.
+
+![npm (scoped)](https://img.shields.io/npm/v/@redocly/cli)
+![NPM](https://img.shields.io/npm/l/@redocly/cli)
+
+![OpenAPI 3 CLI toolset](./media/redocly-cli.gif)
+
+## Features
+
+Currently, @redocly/cli supports these features:
+
+- [x] Multifile validation. No need to bundle your file before validation.
+- [x] Lightning-fast validation. Lint a 1 Mb file in less than one second.
+- [x] Built-in rules for common validations.
+- [x] Configurable severity levels for each rule.
+- [x] Human-readable error messages with codeframes and stylish format options.
+- [x] Intuitive suggestions for misspelled types or references.
+- [x] Easy to implement custom rules.
+- [x] Bundle a multifile definition into a single file.
+- [x] Decorators to modify a validated definition during bundling.
+- [x] Preview reference docs for local development.
+- [x] Support for OpenAPI 2 (fka Swagger) and OpenAPI 3.0.
+- [ ] Support for OpenAPI 3.1 ([coming soon](https://github.com/Redocly/redocly-cli/issues/160)).
+
+## What makes this tool different
+
+Unlike other OpenAPI linters, `@redocly/cli` defines the possible type tree of a valid OpenAPI definition and then traverses it. This approach is very similar to how linters for programming languages work and results in major performance benefits over other approaches. Extend functionality at different points in the lifecycle with preprocessors, rules, and decorators.
+
+## TLDR
+
+`npx @redocly/cli lint path-to-root-file.yaml`
+
+## [Read the docs](https://redoc.ly/docs/cli/)
+
+## Credits
+
+Thanks to [graphql-js](https://github.com/graphql/graphql-js) and [eslint](https://github.com/eslint/eslint) for inspiration of the definition traversal approach and to [Swagger](https://github.com/swagger-api/swagger-editor), [Spectral](https://github.com/stoplightio/spectral), and [OAS-Kit](https://github.com/Mermade/oas-kit) for inspiring the ruleset.

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/index");

package/lib/__mocks__/utils.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="jest" />
+export declare const getFallbackEntryPointsOrExit: jest.Mock<any, [entrypoints: any]>;
+export declare const getTotals: jest.Mock<{
+    errors: number;
+}, []>;
+export declare const dumpBundle: jest.Mock<string, []>;
+export declare const slash: jest.Mock<any, any>;
+export declare const pluralize: jest.Mock<any, any>;
+export declare const getExecutionTime: jest.Mock<any, any>;
+export declare const printExecutionTime: jest.Mock<any, any>;
+export declare const printUnusedWarnings: jest.Mock<any, any>;
+export declare const printLintTotals: jest.Mock<any, any>;
+export declare const getOutputFileName: jest.Mock<{
+    outputFile: string;
+    ext: string;
+}, []>;
+export declare const handleError: jest.Mock<any, any>;

package/lib/__mocks__/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.getOutputFileName = exports.printLintTotals = exports.printUnusedWarnings = exports.printExecutionTime = exports.getExecutionTime = exports.pluralize = exports.slash = exports.dumpBundle = exports.getTotals = exports.getFallbackEntryPointsOrExit = void 0;
+exports.getFallbackEntryPointsOrExit = jest.fn((entrypoints) => entrypoints.map(() => ({ path: '' })));
+exports.getTotals = jest.fn(() => ({ errors: 0 }));
+exports.dumpBundle = jest.fn(() => '');
+exports.slash = jest.fn();
+exports.pluralize = jest.fn();
+exports.getExecutionTime = jest.fn();
+exports.printExecutionTime = jest.fn();
+exports.printUnusedWarnings = jest.fn();
+exports.printLintTotals = jest.fn();
+exports.getOutputFileName = jest.fn(() => ({ outputFile: 'test.yaml', ext: 'yaml' }));
+exports.handleError = jest.fn();

package/lib/__tests__/commands/bundle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/commands/bundle.test.js

@@ -0,0 +1,92 @@
+"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 });
+const openapi_core_1 = require("@redocly/openapi-core");
+const bundle_1 = require("../../commands/bundle");
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+openapi_core_1.getMergedConfig.mockImplementation(config => config);
+describe('bundle', () => {
+    let processExitMock;
+    let exitCb;
+    beforeEach(() => {
+        processExitMock = jest.spyOn(process, 'exit').mockImplementation();
+        jest.spyOn(process, 'once').mockImplementation((_e, cb) => {
+            exitCb = cb;
+            return process.on(_e, cb);
+        });
+        jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        openapi_core_1.lint.mockClear();
+        openapi_core_1.bundle.mockClear();
+        openapi_core_1.getTotals.mockClear();
+    });
+    it('bundles definitions w/o linting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+        }, '1.0.0');
+        expect(openapi_core_1.lint).toBeCalledTimes(0);
+        expect(openapi_core_1.bundle).toBeCalledTimes(entrypoints.length);
+    }));
+    it('exits with code 0 when bundles definitions', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+        }, '1.0.0');
+        exitCb === null || exitCb === void 0 ? void 0 : exitCb();
+        expect(processExitMock).toHaveBeenCalledWith(0);
+    }));
+    it('bundles definitions w/ linting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+            lint: true,
+        }, '1.0.0');
+        expect(openapi_core_1.lint).toBeCalledTimes(entrypoints.length);
+        expect(openapi_core_1.bundle).toBeCalledTimes(entrypoints.length);
+    }));
+    it('exits with code 0 when bundles definitions w/linting w/o errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+            lint: true,
+        }, '1.0.0');
+        exitCb === null || exitCb === void 0 ? void 0 : exitCb();
+        expect(processExitMock).toHaveBeenCalledWith(0);
+    }));
+    it('exits with code 1 when bundles definitions w/linting w/errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml'];
+        openapi_core_1.getTotals.mockReturnValue({
+            errors: 1,
+            warnings: 0,
+            ignored: 0
+        });
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+            lint: true,
+        }, '1.0.0');
+        expect(openapi_core_1.lint).toBeCalledTimes(entrypoints.length);
+        exitCb === null || exitCb === void 0 ? void 0 : exitCb();
+        expect(processExitMock).toHaveBeenCalledWith(1);
+    }));
+});

package/lib/__tests__/commands/push-region.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/commands/push-region.test.js

@@ -0,0 +1,55 @@
+"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 });
+const openapi_core_1 = require("@redocly/openapi-core");
+const push_1 = require("../../commands/push");
+const login_1 = require("../../commands/login");
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+    default: jest.fn(() => ({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+    })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../commands/login');
+jest.mock('../../utils');
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+const mockPromptClientToken = login_1.promptClientToken;
+describe('push-with-region', () => {
+    const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    redoclyClient.isAuthorizedWithRedoclyByRegion = jest.fn().mockResolvedValue(false);
+    beforeAll(() => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    it('should call login with default domain when region is US', () => __awaiter(void 0, void 0, void 0, function* () {
+        redoclyClient.domain = 'redoc.ly';
+        yield push_1.handlePush({
+            upsert: true,
+            entrypoint: 'spec.json',
+            destination: '@org/my-api@1.0.0',
+            branchName: 'test',
+        });
+        expect(mockPromptClientToken).toBeCalledTimes(1);
+        expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+    }));
+    it('should call login with EU domain when region is EU', () => __awaiter(void 0, void 0, void 0, function* () {
+        redoclyClient.domain = 'eu.redocly.com';
+        yield push_1.handlePush({
+            upsert: true,
+            entrypoint: 'spec.json',
+            destination: '@org/my-api@1.0.0',
+            branchName: 'test',
+        });
+        expect(mockPromptClientToken).toBeCalledTimes(1);
+        expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+    }));
+});

package/lib/__tests__/commands/push.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/commands/push.test.js

@@ -0,0 +1,153 @@
+"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 });
+const openapi_core_1 = require("@redocly/openapi-core");
+const push_1 = require("../../commands/push");
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+    default: jest.fn(() => ({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+    })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+describe('push', () => {
+    const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    beforeEach(() => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    it('pushes definition', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield push_1.handlePush({
+            upsert: true,
+            entrypoint: 'spec.json',
+            destination: '@org/my-api@1.0.0',
+            branchName: 'test',
+        });
+        expect(redoclyClient.registryApi.prepareFileUpload).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toHaveBeenLastCalledWith({
+            branch: 'test',
+            filePaths: ['filePath'],
+            isUpsert: true,
+            name: 'my-api',
+            organizationId: 'org',
+            rootFilePath: 'filePath',
+            version: '1.0.0',
+        });
+    }));
+});
+describe('transformPush', () => {
+    it('should adapt the existing syntax', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+            maybeDestination: '@testing_org/main@v1',
+        });
+        expect(cb).toBeCalledWith({
+            entrypoint: 'openapi.yaml',
+            destination: '@testing_org/main@v1',
+        });
+    });
+    it('should adapt the existing syntax (including branchName)', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+            maybeDestination: '@testing_org/main@v1',
+            maybeBranchName: 'other',
+        });
+        expect(cb).toBeCalledWith({
+            entrypoint: 'openapi.yaml',
+            destination: '@testing_org/main@v1',
+            branchName: 'other',
+        });
+    });
+    it('should use --branch option firstly', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+            maybeDestination: '@testing_org/main@v1',
+            maybeBranchName: 'other',
+            branch: 'priority-branch',
+        });
+        expect(cb).toBeCalledWith({
+            entrypoint: 'openapi.yaml',
+            destination: '@testing_org/main@v1',
+            branchName: 'priority-branch',
+        });
+    });
+    it('should work for a destination only', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: '@testing_org/main@v1',
+        });
+        expect(cb).toBeCalledWith({
+            destination: '@testing_org/main@v1',
+        });
+    });
+    it('should accept aliases for the old syntax', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'alias',
+            maybeDestination: '@testing_org/main@v1',
+        });
+        expect(cb).toBeCalledWith({
+            destination: '@testing_org/main@v1',
+            entrypoint: 'alias',
+        });
+    });
+    it('should accept no arguments at all', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({});
+        expect(cb).toBeCalledWith({});
+    });
+});
+describe('getDestinationProps', () => {
+    it('should get valid destination props for the full destination syntax', () => {
+        expect(push_1.getDestinationProps('@testing_org/main@v1', 'org-from-config')).toEqual([
+            'testing_org',
+            'main',
+            'v1',
+        ]);
+    });
+    it('should fallback the organizationId from a config for the short destination syntax', () => {
+        expect(push_1.getDestinationProps('main@v1', 'org-from-config')).toEqual([
+            'org-from-config',
+            'main',
+            'v1',
+        ]);
+    });
+    it('should fallback the organizationId from a config if no destination provided', () => {
+        expect(push_1.getDestinationProps(undefined, 'org-from-config')).toEqual(['org-from-config']);
+    });
+    it('should return empty organizationId if there is no one found', () => {
+        expect(push_1.getDestinationProps('main@v1', undefined)).toEqual([, 'main', 'v1']);
+    });
+});
+describe('getApiEntrypoint', () => {
+    let config = {
+        apis: {
+            'main@v1': {
+                root: 'openapi.yaml',
+            },
+            main: {
+                root: 'latest.yaml',
+            },
+        },
+    };
+    it('should resolve the correct api for a valid name & version', () => {
+        expect(push_1.getApiEntrypoint({ name: 'main', version: 'v1', config })).toEqual('openapi.yaml');
+    });
+    it('should resolve the latest version of api if there is no matching version', () => {
+        expect(push_1.getApiEntrypoint({ name: 'main', version: 'latest', config })).toEqual('latest.yaml');
+    });
+});

package/lib/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/utils.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+jest.mock("os");
+describe('isSubdir', () => {
+    it('can correctly determine if subdir', () => {
+        [
+            ['/foo', '/foo', false],
+            ['/foo', '/bar', false],
+            ['/foo', '/foobar', false],
+            ['/foo', '/foo/bar', true],
+            ['/foo', '/foo/../bar', false],
+            ['/foo', '/foo/./bar', true],
+            ['/bar/../foo', '/foo/bar', true],
+            ['/foo', './bar', false],
+            ['/foo', '/foo/..bar', true],
+        ].forEach(([parent, child, expectRes]) => {
+            expect(utils_1.isSubdir(parent, child)).toBe(expectRes);
+        });
+    });
+    it('can correctly determine if subdir for windows-based paths', () => {
+        const os = require('os');
+        os.platform.mockImplementation(() => 'win32');
+        [
+            ['C:/Foo', 'C:/Foo/Bar', true],
+            ['C:\\Foo', 'C:\\Bar', false],
+            ['C:\\Foo', 'D:\\Foo\\Bar', false],
+        ].forEach(([parent, child, expectRes]) => {
+            expect(utils_1.isSubdir(parent, child)).toBe(expectRes);
+        });
+    });
+    afterEach(() => {
+        jest.resetModules();
+    });
+});
+describe('pathToFilename', () => {
+    it('should use correct path separator', () => {
+        const processedPath = utils_1.pathToFilename('/user/createWithList', '_');
+        expect(processedPath).toEqual('user_createWithList');
+    });
+});

package/lib/assert-node-version.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/assert-node-version.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const utils_1 = require("./utils");
+try {
+    require('assert-node-version')(path.join(__dirname, '../'));
+}
+catch (err) {
+    utils_1.exitWithError(err.message);
+}

package/lib/commands/bundle.d.ts

@@ -0,0 +1,19 @@
+import { OutputFormat } from '@redocly/openapi-core';
+import { OutputExtensions } from '../types';
+export declare function handleBundle(argv: {
+    entrypoints: string[];
+    output?: string;
+    ext: OutputExtensions;
+    'max-problems'?: number;
+    'skip-rule'?: string[];
+    'skip-preprocessor'?: string[];
+    'skip-decorator'?: string[];
+    dereferenced?: boolean;
+    force?: boolean;
+    config?: string;
+    lint?: boolean;
+    format: OutputFormat;
+    metafile?: string;
+    extends?: string[];
+    'remove-unused-components'?: boolean;
+}, version: string): Promise<void>;

package/lib/commands/bundle.js

@@ -0,0 +1,128 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBundle = void 0;
+const openapi_core_1 = require("@redocly/openapi-core");
+const utils_1 = require("../utils");
+const perf_hooks_1 = require("perf_hooks");
+const colorette_1 = require("colorette");
+const fs_1 = require("fs");
+function handleBundle(argv, version) {
+    var _a, _b, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = yield openapi_core_1.loadConfig(argv.config, argv.extends);
+        const removeUnusedComponents = argv['remove-unused-components'] &&
+            !((_b = (_a = config.rawConfig.lint) === null || _a === void 0 ? void 0 : _a.decorators) === null || _b === void 0 ? void 0 : _b.hasOwnProperty('remove-unused-components'));
+        const entrypoints = yield utils_1.getFallbackEntryPointsOrExit(argv.entrypoints, config);
+        const totals = { errors: 0, warnings: 0, ignored: 0 };
+        const maxProblems = argv['max-problems'];
+        for (const { path, alias } of entrypoints) {
+            try {
+                const startedAt = perf_hooks_1.performance.now();
+                const resolvedConfig = openapi_core_1.getMergedConfig(config, alias);
+                resolvedConfig.lint.skipRules(argv['skip-rule']);
+                resolvedConfig.lint.skipPreprocessors(argv['skip-preprocessor']);
+                resolvedConfig.lint.skipDecorators(argv['skip-decorator']);
+                if (argv.lint) {
+                    if (config.lint.recommendedFallback) {
+                        process.stderr.write(`No configurations were defined in extends -- using built in ${colorette_1.blue('recommended')} configuration by default.\n${colorette_1.red('Warning! This default behavior is going to be deprecated soon.')}\n\n`);
+                    }
+                    const results = yield openapi_core_1.lint({
+                        ref: path,
+                        config: resolvedConfig,
+                    });
+                    const fileLintTotals = openapi_core_1.getTotals(results);
+                    totals.errors += fileLintTotals.errors;
+                    totals.warnings += fileLintTotals.warnings;
+                    totals.ignored += fileLintTotals.ignored;
+                    openapi_core_1.formatProblems(results, {
+                        format: argv.format || 'codeframe',
+                        totals: fileLintTotals,
+                        version,
+                        maxProblems,
+                    });
+                    utils_1.printLintTotals(fileLintTotals, 2);
+                }
+                process.stderr.write(colorette_1.gray(`bundling ${path}...\n`));
+                const _e = yield openapi_core_1.bundle({
+                    config: resolvedConfig,
+                    ref: path,
+                    dereference: argv.dereferenced,
+                    removeUnusedComponents,
+                }), { bundle: result, problems } = _e, meta = __rest(_e, ["bundle", "problems"]);
+                const fileTotals = openapi_core_1.getTotals(problems);
+                const { outputFile, ext } = utils_1.getOutputFileName(path, entrypoints.length, argv.output, argv.ext);
+                if (fileTotals.errors === 0 || argv.force) {
+                    if (!argv.output) {
+                        const output = utils_1.dumpBundle(result.parsed, argv.ext || 'yaml', argv.dereferenced);
+                        process.stdout.write(output);
+                    }
+                    else {
+                        const output = utils_1.dumpBundle(result.parsed, ext, argv.dereferenced);
+                        utils_1.saveBundle(outputFile, output);
+                    }
+                }
+                totals.errors += fileTotals.errors;
+                totals.warnings += fileTotals.warnings;
+                totals.ignored += fileTotals.ignored;
+                openapi_core_1.formatProblems(problems, {
+                    format: argv.format,
+                    maxProblems,
+                    totals: fileTotals,
+                    version,
+                });
+                if (argv.metafile) {
+                    if (entrypoints.length > 1) {
+                        process.stderr.write(colorette_1.yellow(`[WARNING] "--metafile" cannot be used with multiple entrypoints. Skipping...`));
+                    }
+                    {
+                        fs_1.writeFileSync(argv.metafile, JSON.stringify(meta), 'utf-8');
+                    }
+                }
+                const elapsed = utils_1.getExecutionTime(startedAt);
+                if (fileTotals.errors > 0) {
+                    if (argv.force) {
+                        process.stderr.write(`❓ Created a bundle for ${colorette_1.blue(path)} at ${colorette_1.blue(outputFile)} with errors ${colorette_1.green(elapsed)}.\n${colorette_1.yellow('Errors ignored because of --force')}.\n`);
+                    }
+                    else {
+                        process.stderr.write(`❌ Errors encountered while bundling ${colorette_1.blue(path)}: bundle not created (use --force to ignore errors).\n`);
+                    }
+                }
+                else {
+                    process.stderr.write(`📦 Created a bundle for ${colorette_1.blue(path)} at ${colorette_1.blue(outputFile)} ${colorette_1.green(elapsed)}.\n`);
+                }
+                const removedCount = (_d = (_c = meta.visitorsData) === null || _c === void 0 ? void 0 : _c['remove-unused-components']) === null || _d === void 0 ? void 0 : _d.removedCount;
+                if (removedCount) {
+                    process.stderr.write(colorette_1.gray(`🧹 Removed ${removedCount} unused components.\n`));
+                }
+            }
+            catch (e) {
+                utils_1.handleError(e, path);
+            }
+        }
+        utils_1.printUnusedWarnings(config.lint);
+        // defer process exit to allow STDOUT pipe to flush
+        // see https://github.com/nodejs/node-v0.x-archive/issues/3737#issuecomment-19156072
+        process.once('exit', () => process.exit(totals.errors === 0 || argv.force ? 0 : 1));
+    });
+}
+exports.handleBundle = handleBundle;

package/lib/commands/join.d.ts

@@ -0,0 +1,7 @@
+export declare function handleJoin(argv: {
+    entrypoints: string[];
+    lint?: boolean;
+    'prefix-tags-with-info-prop'?: string;
+    'prefix-tags-with-filename'?: boolean;
+    'prefix-components-with-info-prop'?: string;
+}, packageVersion: string): Promise<void>;