openapi-modifier/dist/src/openapi.js

This package allows you to automate the process of modifying OpenAPI specifications by applying a set of predefined rules

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.writeOutputFile = exports.readInputFile = void 0;
const yaml_1 = __importDefault(require("yaml"));
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const json_stringify_nice_1 = __importDefault(require("json-stringify-nice"));
const checkIsAvailableFileExtension = (extensions) => {
    return ['.json', '.yaml', '.yml'].includes(extensions);
};
const readInputFile = (baseLogger, inputPath) => {
    const logger = baseLogger.clone('input-file');
    let contentBuffer;
    try {
        const absoluteInputPath = path_1.default.isAbsolute(inputPath) ? inputPath : path_1.default.resolve(process.cwd(), inputPath);
        logger.trace(`Absolute input path: ${absoluteInputPath}`);
        contentBuffer = fs_1.default.readFileSync(absoluteInputPath);
    }
    catch (error) {
        if (error instanceof Error) {
            logger.error(error, `Not found input file: ${inputPath}`);
        }
        throw error;
    }
    const content = contentBuffer.toString();
    const inputFileExtension = path_1.default.extname(inputPath) || null;
    logger.trace(`Input file extension: ${inputFileExtension}`);
    if (!checkIsAvailableFileExtension(inputFileExtension)) {
        throw new Error(`Not processable extension! ${inputFileExtension}`);
    }
    let document = null;
    try {
        switch (inputFileExtension) {
            case '.yml':
            case '.yaml': {
                document = yaml_1.default.parse(content);
                break;
            }
            case '.json': {
                document = JSON.parse(content);
                break;
            }
        }
    }
    catch (error) {
        if (error instanceof Error) {
            logger.error(error, `Parse input file: ${content}`);
        }
        throw error;
    }
    if (!document) {
        throw new Error('Empty input file!');
    }
    return {
        context: {
            sourcePath: inputPath,
            sourceExtension: inputFileExtension,
        },
        document,
    };
};
exports.readInputFile = readInputFile;
const writeOutputFile = (baseLogger, outputPath, file) => {
    const logger = baseLogger.clone('output-file');
    const outputFileExtension = path_1.default.extname(outputPath) || null;
    logger.trace(`Input file extension: ${outputFileExtension}`);
    if (!checkIsAvailableFileExtension(outputFileExtension)) {
        throw new Error(`Not processable extension! ${outputFileExtension}`);
    }
    let content;
    try {
        switch (outputFileExtension) {
            case '.yml':
            case '.yaml': {
                content = yaml_1.default.stringify(file.document, {
                    sortMapEntries: true,
                });
                break;
            }
            case '.json': {
                content = (0, json_stringify_nice_1.default)(file.document, null, 4);
                break;
            }
        }
    }
    catch (error) {
        if (error instanceof Error) {
            logger.error(error, 'Failed to stringified output');
        }
        throw error;
    }
    if (!content) {
        throw new Error('Empty content!');
    }
    try {
        const absoluteOutputPath = path_1.default.isAbsolute(outputPath) ? outputPath : path_1.default.resolve(process.cwd(), outputPath);
        logger.trace(`Absolute output path: ${absoluteOutputPath}`);
        fs_1.default.mkdirSync(path_1.default.dirname(absoluteOutputPath), { recursive: true });
        fs_1.default.writeFileSync(absoluteOutputPath, content);
    }
    catch (error) {
        if (error instanceof Error) {
            logger.error(error, `Failed to output file: ${outputPath}`);
        }
        throw error;
    }
};
exports.writeOutputFile = writeOutputFile;