@redocly/cli 1.0.0-beta.96

package/lib/commands/push.js

@@ -0,0 +1,247 @@
+"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.getApiEntrypoint = exports.transformPush = exports.getDestinationProps = exports.handlePush = void 0;
+const fs = require("fs");
+const path = require("path");
+const node_fetch_1 = require("node-fetch");
+const perf_hooks_1 = require("perf_hooks");
+const colorette_1 = require("colorette");
+const crypto_1 = require("crypto");
+const openapi_core_1 = require("@redocly/openapi-core");
+const utils_1 = require("../utils");
+const login_1 = require("./login");
+const DEFAULT_VERSION = 'latest';
+function handlePush(argv) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = yield openapi_core_1.loadConfig();
+        const region = argv.region || config.region;
+        const client = new openapi_core_1.RedoclyClient(region);
+        const isAuthorized = yield client.isAuthorizedWithRedoclyByRegion();
+        if (!isAuthorized) {
+            const clientToken = yield login_1.promptClientToken(client.domain);
+            yield client.login(clientToken);
+        }
+        const startedAt = perf_hooks_1.performance.now();
+        const { destination, branchName, upsert } = argv;
+        if (destination &&
+            !(validateDestination(destination) || validateDestinationWithoutOrganization(destination))) {
+            utils_1.exitWithError(`Destination argument value is not valid, please use the right format: ${colorette_1.yellow('<@organization-id/api-name@api-version>')}`);
+        }
+        const [organizationId, name, version] = getDestinationProps(destination, config.organization);
+        if (!organizationId) {
+            return utils_1.exitWithError(`No organization provided, please use the right format: ${colorette_1.yellow('<@organization-id/api-name@api-version>')} or specify the 'organization' field in the config file.`);
+        }
+        const entrypoint = argv.entrypoint || (name && version && getApiEntrypoint({ name, version, config }));
+        if (name && version && !entrypoint) {
+            utils_1.exitWithError(`No entrypoint found that matches ${colorette_1.blue(`${name}@${version}`)}. Please make sure you have provided the correct data in the config file.`);
+        }
+        const apis = entrypoint ? { [`${name}@${version}`]: { root: entrypoint } } : config.apis;
+        for (const [apiNameAndVersion, { root: entrypoint }] of Object.entries(apis)) {
+            const resolvedConfig = openapi_core_1.getMergedConfig(config, apiNameAndVersion);
+            resolvedConfig.lint.skipDecorators(argv['skip-decorator']);
+            const [name, version = DEFAULT_VERSION] = apiNameAndVersion.split('@');
+            try {
+                let rootFilePath = '';
+                const filePaths = [];
+                const filesToUpload = yield collectFilesToUpload(entrypoint, resolvedConfig);
+                const filesHash = hashFiles(filesToUpload.files);
+                process.stdout.write(`Uploading ${filesToUpload.files.length} ${utils_1.pluralize('file', filesToUpload.files.length)}:\n`);
+                let uploaded = 0;
+                for (let file of filesToUpload.files) {
+                    const { signedUploadUrl, filePath } = yield client.registryApi.prepareFileUpload({
+                        organizationId,
+                        name,
+                        version,
+                        filesHash,
+                        filename: file.keyOnS3,
+                        isUpsert: upsert,
+                    });
+                    if (file.filePath === filesToUpload.root) {
+                        rootFilePath = filePath;
+                    }
+                    filePaths.push(filePath);
+                    process.stdout.write(`Uploading ${file.contents ? 'bundle for ' : ''}${colorette_1.blue(file.filePath)}...`);
+                    const uploadResponse = yield uploadFileToS3(signedUploadUrl, file.contents || file.filePath);
+                    const fileCounter = `(${++uploaded}/${filesToUpload.files.length})`;
+                    if (!uploadResponse.ok) {
+                        utils_1.exitWithError(`✗ ${fileCounter}\nFile upload failed\n`);
+                    }
+                    process.stdout.write(colorette_1.green(`✓ ${fileCounter}\n`));
+                }
+                process.stdout.write('\n');
+                yield client.registryApi.pushApi({
+                    organizationId,
+                    name,
+                    version,
+                    rootFilePath,
+                    filePaths,
+                    branch: branchName,
+                    isUpsert: upsert,
+                });
+            }
+            catch (error) {
+                if (error.message === 'ORGANIZATION_NOT_FOUND') {
+                    utils_1.exitWithError(`Organization ${colorette_1.blue(organizationId)} not found`);
+                }
+                if (error.message === 'API_VERSION_NOT_FOUND') {
+                    utils_1.exitWithError(`The definition version ${colorette_1.blue(name)}/${colorette_1.blue(version)} does not exist in organization ${colorette_1.blue(organizationId)}!\n${colorette_1.yellow('Suggestion:')} please use ${colorette_1.blue('-u')} or ${colorette_1.blue('--upsert')} to create definition.
+        `);
+                }
+                throw error;
+            }
+            process.stdout.write(`Definition: ${colorette_1.blue(entrypoint)} is successfully pushed to Redocly API Registry \n`);
+        }
+        utils_1.printExecutionTime('push', startedAt, entrypoint || `apis in organization ${organizationId}`);
+    });
+}
+exports.handlePush = handlePush;
+function getFilesList(dir, files) {
+    files = files || [];
+    const filesAndDirs = fs.readdirSync(dir);
+    for (const name of filesAndDirs) {
+        if (fs.statSync(path.join(dir, name)).isDirectory()) {
+            files = getFilesList(path.join(dir, name), files);
+        }
+        else {
+            const currentPath = dir + '/' + name;
+            files.push(currentPath);
+        }
+    }
+    return files;
+}
+function collectFilesToUpload(entrypoint, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let files = [];
+        const [{ path: entrypointPath }] = yield utils_1.getFallbackEntryPointsOrExit([entrypoint], config);
+        process.stdout.write('Bundling definition\n');
+        const { bundle: openapiBundle, problems } = yield openapi_core_1.bundle({
+            config,
+            ref: entrypointPath,
+            skipRedoclyRegistryRefs: true,
+        });
+        const fileTotals = openapi_core_1.getTotals(problems);
+        if (fileTotals.errors === 0) {
+            process.stdout.write(`Created a bundle for ${colorette_1.blue(entrypoint)} ${fileTotals.warnings > 0 ? 'with warnings' : ''}\n`);
+        }
+        else {
+            utils_1.exitWithError(`Failed to create a bundle for ${colorette_1.blue(entrypoint)}\n`);
+        }
+        const fileExt = path.extname(entrypointPath).split('.').pop();
+        files.push(getFileEntry(entrypointPath, utils_1.dumpBundle(openapiBundle.parsed, fileExt)));
+        if (fs.existsSync('package.json')) {
+            files.push(getFileEntry('package.json'));
+        }
+        if (fs.existsSync(openapi_core_1.IGNORE_FILE)) {
+            files.push(getFileEntry(openapi_core_1.IGNORE_FILE));
+        }
+        if (config.configFile) {
+            // All config file paths including the root one
+            files.push(...[...new Set(config.lint.extendPaths)].map((f) => getFileEntry(f)));
+            if (config['features.openapi'].htmlTemplate) {
+                const dir = getFolder(config['features.openapi'].htmlTemplate);
+                const fileList = getFilesList(dir, []);
+                files.push(...fileList.map((f) => getFileEntry(f)));
+            }
+            let pluginFiles = new Set();
+            for (const plugin of config.lint.pluginPaths) {
+                if (typeof plugin !== 'string')
+                    continue;
+                const fileList = getFilesList(getFolder(plugin), []);
+                fileList.forEach((f) => pluginFiles.add(f));
+            }
+            files.push(...filterPluginFilesByExt(Array.from(pluginFiles)).map((f) => getFileEntry(f)));
+        }
+        return {
+            files,
+            root: path.resolve(entrypointPath),
+        };
+        function filterPluginFilesByExt(files) {
+            return files.filter((file) => {
+                const fileExt = path.extname(file).toLowerCase();
+                return fileExt === '.js' || fileExt === '.ts' || fileExt === '.mjs' || fileExt === 'json';
+            });
+        }
+        function getFileEntry(filename, contents) {
+            return {
+                filePath: path.resolve(filename),
+                keyOnS3: config.configFile
+                    ? openapi_core_1.slash(path.relative(path.dirname(config.configFile), filename))
+                    : openapi_core_1.slash(path.basename(filename)),
+                contents: (contents && Buffer.from(contents, 'utf-8')) || undefined,
+            };
+        }
+    });
+}
+function getFolder(filePath) {
+    return path.resolve(path.dirname(filePath));
+}
+function hashFiles(filePaths) {
+    let sum = crypto_1.createHash('sha256');
+    filePaths.forEach((file) => sum.update(fs.readFileSync(file.filePath)));
+    return sum.digest('hex');
+}
+function validateDestination(destination) {
+    const regexp = /^@+([a-zA-Z0-9-_.& ]+)\/+([^@\/]+)@([^@\/]+)$/;
+    return regexp.test(destination);
+}
+function validateDestinationWithoutOrganization(destination) {
+    const regexp = /^()([^@\/]+)@([^@\/]+)$/;
+    return regexp.test(destination);
+}
+function getDestinationProps(destination, organization) {
+    return destination && validateDestination(destination)
+        ? destination.substring(1).split(/[@\/]/)
+        : destination && validateDestinationWithoutOrganization(destination)
+            ? [organization, ...destination.split('@')]
+            : [organization];
+}
+exports.getDestinationProps = getDestinationProps;
+const transformPush = (callback) => (_a) => {
+    var { maybeEntrypointOrAliasOrDestination, maybeDestination, maybeBranchName, branch } = _a, rest = __rest(_a, ["maybeEntrypointOrAliasOrDestination", "maybeDestination", "maybeBranchName", "branch"]);
+    if (!!maybeBranchName) {
+        process.stderr.write(colorette_1.yellow('Deprecation warning: Do not use the third parameter as a branch name. Please use a separate --branch option instead.'));
+    }
+    const entrypoint = maybeDestination ? maybeEntrypointOrAliasOrDestination : undefined;
+    const destination = maybeDestination || maybeEntrypointOrAliasOrDestination;
+    return callback(Object.assign(Object.assign({}, rest), { destination,
+        entrypoint, branchName: branch !== null && branch !== void 0 ? branch : maybeBranchName }));
+};
+exports.transformPush = transformPush;
+function getApiEntrypoint({ name, version, config: { apis }, }) {
+    const api = (apis === null || apis === void 0 ? void 0 : apis[`${name}@${version}`]) || (version === DEFAULT_VERSION && (apis === null || apis === void 0 ? void 0 : apis[name]));
+    return api === null || api === void 0 ? void 0 : api.root;
+}
+exports.getApiEntrypoint = getApiEntrypoint;
+function uploadFileToS3(url, filePathOrBuffer) {
+    const fileSizeInBytes = typeof filePathOrBuffer === 'string'
+        ? fs.statSync(filePathOrBuffer).size
+        : filePathOrBuffer.byteLength;
+    let readStream = typeof filePathOrBuffer === 'string' ? fs.createReadStream(filePathOrBuffer) : filePathOrBuffer;
+    return node_fetch_1.default(url, {
+        method: 'PUT',
+        headers: {
+            'Content-Length': fileSizeInBytes.toString(),
+        },
+        body: readStream,
+    });
+}

package/lib/commands/split/__tests__/index.test.d.ts

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

package/lib/commands/split/__tests__/index.test.js

@@ -0,0 +1,70 @@
+"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 index_1 = require("../index");
+const path = require("path");
+const openapiCore = require("@redocly/openapi-core");
+const colorette_1 = require("colorette");
+jest.mock('../../../utils', () => (Object.assign(Object.assign({}, jest.requireActual('../../../utils')), { writeYaml: jest.fn() })));
+jest.mock('@redocly/openapi-core', () => (Object.assign(Object.assign({}, jest.requireActual('@redocly/openapi-core')), { isRef: jest.fn() })));
+describe('#split', () => {
+    const openapiDir = 'test';
+    const componentsFiles = {};
+    it('should split the file and show the success message', () => __awaiter(void 0, void 0, void 0, function* () {
+        const filePath = "./packages/cli/src/commands/split/__tests__/fixtures/spec.json";
+        jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        yield index_1.handleSplit({
+            entrypoint: filePath,
+            outDir: openapiDir,
+            separator: '_',
+        });
+        expect(process.stderr.write).toBeCalledTimes(2);
+        expect(process.stderr.write.mock.calls[0][0]).toBe(`🪓 Document: ${colorette_1.blue(filePath)} ${colorette_1.green('is successfully split')}
+    and all related files are saved to the directory: ${colorette_1.blue(openapiDir)} \n`);
+        expect(process.stderr.write.mock.calls[1][0]).toContain(`${filePath}: split processed in <test>ms`);
+    }));
+    it('should use the correct separator', () => __awaiter(void 0, void 0, void 0, function* () {
+        const filePath = "./packages/cli/src/commands/split/__tests__/fixtures/spec.json";
+        const utils = require('../../../utils');
+        jest.spyOn(utils, 'pathToFilename').mockImplementation(() => 'newFilePath');
+        yield index_1.handleSplit({
+            entrypoint: filePath,
+            outDir: openapiDir,
+            separator: '_',
+        });
+        expect(utils.pathToFilename).toBeCalledWith(expect.anything(), '_');
+        utils.pathToFilename.mockRestore();
+    }));
+    it('should have correct path with paths', () => {
+        const openapi = require("./fixtures/spec.json");
+        jest.spyOn(openapiCore, 'slash').mockImplementation(() => 'paths/test.yaml');
+        jest.spyOn(path, 'relative').mockImplementation(() => 'paths/test.yaml');
+        index_1.iteratePathItems(openapi.paths, openapiDir, path.join(openapiDir, 'paths'), componentsFiles, '_');
+        expect(openapiCore.slash).toHaveBeenCalledWith('paths/test.yaml');
+        expect(path.relative).toHaveBeenCalledWith('test', 'test/paths/test.yaml');
+    });
+    it('should have correct path with webhooks', () => {
+        const openapi = require("./fixtures/webhooks.json");
+        jest.spyOn(openapiCore, 'slash').mockImplementation(() => 'webhooks/test.yaml');
+        jest.spyOn(path, 'relative').mockImplementation(() => 'webhooks/test.yaml');
+        index_1.iteratePathItems(openapi.webhooks, openapiDir, path.join(openapiDir, 'webhooks'), componentsFiles, 'webhook_');
+        expect(openapiCore.slash).toHaveBeenCalledWith('webhooks/test.yaml');
+        expect(path.relative).toHaveBeenCalledWith('test', 'test/webhooks/test.yaml');
+    });
+    it('should have correct path with x-webhooks', () => {
+        const openapi = require("./fixtures/spec.json");
+        jest.spyOn(openapiCore, 'slash').mockImplementation(() => 'webhooks/test.yaml');
+        jest.spyOn(path, 'relative').mockImplementation(() => 'webhooks/test.yaml');
+        index_1.iteratePathItems(openapi['x-webhooks'], openapiDir, path.join(openapiDir, 'webhooks'), componentsFiles, 'webhook_');
+        expect(openapiCore.slash).toHaveBeenCalledWith('webhooks/test.yaml');
+        expect(path.relative).toHaveBeenCalledWith('test', 'test/webhooks/test.yaml');
+    });
+});

package/lib/commands/split/index.d.ts

@@ -0,0 +1,8 @@
+import { Oas3PathItem, Referenced } from './types';
+export declare function handleSplit(argv: {
+    entrypoint: string;
+    outDir: string;
+    separator: string;
+}): Promise<void>;
+declare function iteratePathItems(pathItems: Record<string, Referenced<Oas3PathItem>> | undefined, openapiDir: string, outDir: string, componentsFiles: object, pathSeparator: string, codeSamplesPathPrefix?: string): void;
+export { iteratePathItems };

package/lib/commands/split/index.js

@@ -0,0 +1,279 @@
+"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.iteratePathItems = exports.handleSplit = void 0;
+const colorette_1 = require("colorette");
+const fs = require("fs");
+const openapi_core_1 = require("@redocly/openapi-core");
+const path = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const isEqual = require('lodash.isequal');
+const utils_1 = require("../../utils");
+const js_utils_1 = require("../../js-utils");
+const types_1 = require("./types");
+function handleSplit(argv) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const startedAt = perf_hooks_1.performance.now();
+        const { entrypoint, outDir, separator } = argv;
+        validateDefinitionFileName(entrypoint);
+        const openapi = utils_1.readYaml(entrypoint);
+        splitDefinition(openapi, outDir, separator);
+        process.stderr.write(`🪓 Document: ${colorette_1.blue(entrypoint)} ${colorette_1.green('is successfully split')}
+    and all related files are saved to the directory: ${colorette_1.blue(outDir)} \n`);
+        utils_1.printExecutionTime('split', startedAt, entrypoint);
+    });
+}
+exports.handleSplit = handleSplit;
+function splitDefinition(openapi, openapiDir, pathSeparator) {
+    fs.mkdirSync(openapiDir, { recursive: true });
+    const componentsFiles = {};
+    iterateComponents(openapi, openapiDir, componentsFiles);
+    iteratePathItems(openapi.paths, openapiDir, path.join(openapiDir, 'paths'), componentsFiles, pathSeparator);
+    const webhooks = openapi.webhooks || openapi['x-webhooks'];
+    // use webhook_ prefix for code samples to prevent potential name-clashes with paths samples
+    iteratePathItems(webhooks, openapiDir, path.join(openapiDir, 'webhooks'), componentsFiles, pathSeparator, 'webhook_');
+    replace$Refs(openapi, openapiDir, componentsFiles);
+    utils_1.writeYaml(openapi, path.join(openapiDir, 'openapi.yaml'));
+}
+function isStartsWithComponents(node) {
+    return node.startsWith(types_1.componentsPath);
+}
+function isNotYaml(filename) {
+    return !(filename.endsWith('.yaml') || filename.endsWith('.yml'));
+}
+function loadFile(fileName) {
+    try {
+        return openapi_core_1.parseYaml(fs.readFileSync(fileName, 'utf8'));
+    }
+    catch (e) {
+        return utils_1.exitWithError(e.message);
+    }
+}
+function validateDefinitionFileName(fileName) {
+    if (!fs.existsSync(fileName))
+        utils_1.exitWithError(`File ${colorette_1.blue(fileName)} does not exist \n`);
+    const file = loadFile(fileName);
+    if (file.swagger)
+        utils_1.exitWithError('OpenAPI 2 is not supported by this command');
+    if (!file.openapi)
+        utils_1.exitWithError('File does not conform to the OpenAPI Specification. OpenAPI version is not specified');
+    return true;
+}
+function langToExt(lang) {
+    const langObj = {
+        php: '.php',
+        'c#': '.cs',
+        shell: '.sh',
+        curl: '.sh',
+        bash: '.sh',
+        javascript: '.js',
+        js: '.js',
+        python: '.py'
+    };
+    return langObj[lang];
+}
+function traverseDirectoryDeep(directory, callback, componentsFiles) {
+    if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory())
+        return;
+    const files = fs.readdirSync(directory);
+    for (const f of files) {
+        const filename = path.join(directory, f);
+        if (fs.statSync(filename).isDirectory()) {
+            traverseDirectoryDeep(filename, callback, componentsFiles);
+        }
+        else {
+            callback(filename, directory, componentsFiles);
+        }
+    }
+}
+function traverseDirectoryDeepCallback(filename, directory, componentsFiles) {
+    if (isNotYaml(filename))
+        return;
+    const pathData = utils_1.readYaml(filename);
+    replace$Refs(pathData, directory, componentsFiles);
+    utils_1.writeYaml(pathData, filename);
+}
+function crawl(object, visitor) {
+    if (!js_utils_1.isObject(object))
+        return;
+    for (const key of Object.keys(object)) {
+        visitor(object, key);
+        crawl(object[key], visitor);
+    }
+}
+function replace$Refs(obj, relativeFrom, componentFiles = {}) {
+    crawl(obj, (node) => {
+        if (node.$ref && js_utils_1.isString(node.$ref) && isStartsWithComponents(node.$ref)) {
+            replace(node, '$ref');
+        }
+        else if (node.discriminator &&
+            node.discriminator.mapping &&
+            js_utils_1.isObject(node.discriminator.mapping)) {
+            const { mapping } = node.discriminator;
+            for (const name of Object.keys(mapping)) {
+                if (js_utils_1.isString(mapping[name]) && isStartsWithComponents(mapping[name])) {
+                    replace(node.discriminator.mapping, name);
+                }
+            }
+        }
+    });
+    function replace(node, key) {
+        const splittedNode = node[key].split('/');
+        const name = splittedNode.pop();
+        const groupName = splittedNode[2];
+        const filesGroupName = componentFiles[groupName];
+        if (!filesGroupName || !filesGroupName[name])
+            return;
+        let filename = path.relative(relativeFrom, filesGroupName[name].filename);
+        if (!filename.startsWith('.')) {
+            filename = '.' + path.sep + filename;
+        }
+        node[key] = filename;
+    }
+}
+function implicitlyReferenceDiscriminator(obj, defName, filename, schemaFiles) {
+    if (!obj.discriminator)
+        return;
+    const defPtr = `#/${types_1.COMPONENTS}/${types_1.OPENAPI3_COMPONENT.Schemas}/${defName}`;
+    const implicitMapping = {};
+    for (const [name, { inherits, filename: parentFilename }] of Object.entries(schemaFiles)) {
+        if (inherits.indexOf(defPtr) > -1) {
+            const res = path.relative(path.dirname(filename), parentFilename);
+            implicitMapping[name] = res.startsWith('.') ? res : '.' + path.sep + res;
+        }
+    }
+    if (js_utils_1.isEmptyObject(implicitMapping))
+        return;
+    const discriminatorPropSchema = obj.properties[obj.discriminator.propertyName];
+    const discriminatorEnum = discriminatorPropSchema && discriminatorPropSchema.enum;
+    const mapping = (obj.discriminator.mapping = obj.discriminator.mapping || {});
+    for (const name of Object.keys(implicitMapping)) {
+        if (discriminatorEnum && !discriminatorEnum.includes(name)) {
+            continue;
+        }
+        if (mapping[name] && mapping[name] !== implicitMapping[name]) {
+            process.stderr.write(colorette_1.yellow(`warning: explicit mapping overlaps with local mapping entry ${colorette_1.red(name)} at ${colorette_1.blue(filename)}. Please check it.`));
+        }
+        mapping[name] = implicitMapping[name];
+    }
+}
+function isNotSecurityComponentType(componentType) {
+    return componentType !== types_1.OPENAPI3_COMPONENT.SecuritySchemes;
+}
+function findComponentTypes(components) {
+    return types_1.OPENAPI3_COMPONENT_NAMES
+        .filter(item => isNotSecurityComponentType(item) && Object.keys(components).includes(item));
+}
+function doesFileDiffer(filename, componentData) {
+    return fs.existsSync(filename) && !isEqual(utils_1.readYaml(filename), componentData);
+}
+function removeEmptyComponents(openapi, componentType) {
+    if (openapi.components && js_utils_1.isEmptyObject(openapi.components[componentType])) {
+        delete openapi.components[componentType];
+    }
+    if (js_utils_1.isEmptyObject(openapi.components)) {
+        delete openapi.components;
+    }
+}
+function createComponentDir(componentDirPath, componentType) {
+    if (isNotSecurityComponentType(componentType)) {
+        fs.mkdirSync(componentDirPath, { recursive: true });
+    }
+}
+function extractFileNameFromPath(filename) {
+    return path.basename(filename, path.extname(filename));
+}
+function getFileNamePath(componentDirPath, componentName) {
+    return path.join(componentDirPath, componentName) + '.yaml';
+}
+function gatherComponentsFiles(components, componentsFiles, componentType, componentName, filename) {
+    var _a, _b;
+    let inherits = [];
+    if (componentType === types_1.OPENAPI3_COMPONENT.Schemas) {
+        inherits = (((_b = (_a = components === null || components === void 0 ? void 0 : components[componentType]) === null || _a === void 0 ? void 0 : _a[componentName]) === null || _b === void 0 ? void 0 : _b.allOf) || []).map((s) => s.$ref).filter(Boolean);
+    }
+    componentsFiles[componentType] = componentsFiles[componentType] || {};
+    componentsFiles[componentType][componentName] = { inherits, filename };
+}
+function iteratePathItems(pathItems, openapiDir, outDir, componentsFiles, pathSeparator, codeSamplesPathPrefix = '') {
+    if (!pathItems)
+        return;
+    fs.mkdirSync(outDir, { recursive: true });
+    for (const pathName of Object.keys(pathItems)) {
+        const pathFile = `${path.join(outDir, utils_1.pathToFilename(pathName, pathSeparator))}.yaml`;
+        const pathData = pathItems[pathName];
+        if (openapi_core_1.isRef(pathData))
+            continue;
+        for (const method of types_1.OPENAPI3_METHOD_NAMES) {
+            const methodData = pathData[method];
+            const methodDataXCode = (methodData === null || methodData === void 0 ? void 0 : methodData['x-code-samples']) || (methodData === null || methodData === void 0 ? void 0 : methodData['x-codeSamples']);
+            if (!methodDataXCode || !Array.isArray(methodDataXCode)) {
+                continue;
+            }
+            for (const sample of methodDataXCode) {
+                if (sample.source && sample.source.$ref)
+                    continue;
+                const sampleFileName = path.join(openapiDir, 'code_samples', sample.lang, codeSamplesPathPrefix + utils_1.pathToFilename(pathName, pathSeparator), method + langToExt(sample.lang));
+                fs.mkdirSync(path.dirname(sampleFileName), { recursive: true });
+                fs.writeFileSync(sampleFileName, sample.source);
+                // @ts-ignore
+                sample.source = {
+                    $ref: openapi_core_1.slash(path.relative(outDir, sampleFileName))
+                };
+            }
+        }
+        utils_1.writeYaml(pathData, pathFile);
+        pathItems[pathName] = {
+            $ref: openapi_core_1.slash(path.relative(openapiDir, pathFile))
+        };
+        traverseDirectoryDeep(outDir, traverseDirectoryDeepCallback, componentsFiles);
+    }
+}
+exports.iteratePathItems = iteratePathItems;
+function iterateComponents(openapi, openapiDir, componentsFiles) {
+    const { components } = openapi;
+    if (components) {
+        const componentsDir = path.join(openapiDir, types_1.COMPONENTS);
+        fs.mkdirSync(componentsDir, { recursive: true });
+        const componentTypes = findComponentTypes(components);
+        componentTypes.forEach(iterateAndGatherComponentsFiles);
+        componentTypes.forEach(iterateComponentTypes);
+        function iterateAndGatherComponentsFiles(componentType) {
+            const componentDirPath = path.join(componentsDir, componentType);
+            for (const componentName of Object.keys((components === null || components === void 0 ? void 0 : components[componentType]) || {})) {
+                const filename = getFileNamePath(componentDirPath, componentName);
+                gatherComponentsFiles(components, componentsFiles, componentType, componentName, filename);
+            }
+        }
+        function iterateComponentTypes(componentType) {
+            var _a, _b, _c;
+            const componentDirPath = path.join(componentsDir, componentType);
+            createComponentDir(componentDirPath, componentType);
+            for (const componentName of Object.keys((components === null || components === void 0 ? void 0 : components[componentType]) || {})) {
+                const filename = getFileNamePath(componentDirPath, componentName);
+                const componentData = (_a = components === null || components === void 0 ? void 0 : components[componentType]) === null || _a === void 0 ? void 0 : _a[componentName];
+                replace$Refs(componentData, path.dirname(filename), componentsFiles);
+                implicitlyReferenceDiscriminator(componentData, extractFileNameFromPath(filename), filename, componentsFiles.schemas || {});
+                if (doesFileDiffer(filename, componentData)) {
+                    process.stderr.write(colorette_1.yellow(`warning: conflict for ${componentName} - file already exists with different content: ${colorette_1.blue(filename)} ... Skip.\n`));
+                }
+                else {
+                    utils_1.writeYaml(componentData, filename);
+                }
+                if (isNotSecurityComponentType(componentType)) {
+                    // security schemas must referenced from components
+                    (_c = (_b = openapi.components) === null || _b === void 0 ? void 0 : _b[componentType]) === null || _c === void 0 ? true : delete _c[componentName];
+                }
+            }
+            removeEmptyComponents(openapi, componentType);
+        }
+    }
+}

package/lib/commands/split/types.d.ts

@@ -0,0 +1,37 @@
+import { Oas3Schema, Oas3_1Schema, Oas3Definition, Oas3_1Definition, Oas3Components, Oas3PathItem, Oas3Paths, Oas3ComponentName, Oas3_1Webhooks, Oas2Definition, Referenced } from "@redocly/openapi-core";
+export { Oas3_1Definition, Oas3Definition, Oas2Definition, Oas3Components, Oas3Paths, Oas3PathItem, Oas3ComponentName, Oas3_1Schema, Oas3Schema, Oas3_1Webhooks, Referenced };
+export declare type Definition = Oas3_1Definition | Oas3Definition | Oas2Definition;
+export interface ComponentsFiles {
+    [schemas: string]: any;
+}
+export interface refObj {
+    [$ref: string]: string;
+}
+export declare const COMPONENTS = "components";
+export declare const PATHS = "paths";
+export declare const WEBHOOKS = "webhooks";
+export declare const xWEBHOOKS = "x-webhooks";
+export declare const componentsPath: string;
+declare enum OPENAPI3_METHOD {
+    Get = "get",
+    Put = "put",
+    Post = "post",
+    Delete = "delete",
+    Options = "options",
+    Head = "head",
+    Patch = "patch",
+    Trace = "trace"
+}
+export declare const OPENAPI3_METHOD_NAMES: OPENAPI3_METHOD[];
+export declare enum OPENAPI3_COMPONENT {
+    Schemas = "schemas",
+    Responses = "responses",
+    Parameters = "parameters",
+    Examples = "examples",
+    Headers = "headers",
+    RequestBodies = "requestBodies",
+    Links = "links",
+    Callbacks = "callbacks",
+    SecuritySchemes = "securitySchemes"
+}
+export declare const OPENAPI3_COMPONENT_NAMES: OPENAPI3_COMPONENT[];