@argdown/node/dist/plugins/SaveAsFilePlugin.js

Async Argdown application for node.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SaveAsFilePlugin = void 0;
let fs = require("fs");
let path = require("path");
let mkdirp = require("mkdirp");
const lodash_defaultsdeep_1 = __importDefault(require("lodash.defaultsdeep"));
const lodash_isstring_1 = __importDefault(require("lodash.isstring"));
const lodash_isempty_1 = __importDefault(require("lodash.isempty"));
const lodash_isfunction_1 = __importDefault(require("lodash.isfunction"));
const core_1 = require("@argdown/core");
class SaveAsFilePlugin {
    constructor(config) {
        this.name = "SaveAsFilePlugin";
        this.runAsync = async (request, response, logger) => {
            const settings = this.getSettings(request);
            if (!settings.dataKey) {
                throw new core_1.ArgdownPluginError(this.name, "missing-dataKey-setting", "No data key.");
            }
            let fileContent = !settings.isRequestData
                ? response[settings.dataKey]
                : request[settings.dataKey];
            if (fileContent === undefined) {
                throw new core_1.ArgdownPluginError(this.name, "missing-content", "No content to save.");
            }
            if (!(0, lodash_isstring_1.default)(fileContent) && !Buffer.isBuffer(fileContent)) {
                throw new core_1.ArgdownPluginError(this.name, "invalid-content", "Content is neither a string nor a buffer.");
            }
            if ((0, lodash_isempty_1.default)(fileContent)) {
                throw new core_1.ArgdownPluginError(this.name, "missing-content", "Data field is empty string.");
            }
            const dataSettings = !settings.isRequestData && settings.dataKey
                ? request[settings.dataKey]
                : null;
            let fileName = "default";
            let outputDir = settings.outputDir;
            if (request.outputPath) {
                outputDir = path.dirname(request.outputPath);
            }
            else if (dataSettings && dataSettings.outputDir) {
                outputDir = path.dirname(dataSettings.outputDir);
            }
            if (request.outputPath) {
                fileName = this.getFileName(request.outputPath);
            }
            else if ((0, lodash_isfunction_1.default)(settings.fileName)) {
                fileName = settings.fileName.call(this, settings, request, response);
            }
            else if ((0, lodash_isstring_1.default)(settings.fileName)) {
                fileName = settings.fileName;
            }
            else if (request.inputPath) {
                fileName = this.getFileName(request.inputPath);
            }
            if (request.outputSuffix) {
                fileName = fileName + request.outputSuffix;
            }
            if (dataSettings && dataSettings.outputDir) {
                outputDir = dataSettings.outputDir;
            }
            if (outputDir && settings.extension) {
                response.outputPath = await this.saveAsFile(fileContent, outputDir, fileName, settings.extension, logger);
            }
        };
        this.defaults = (0, lodash_defaultsdeep_1.default)({}, config, {
            dataKey: "test",
            extension: ".txt",
            outputDir: "./output"
        });
    }
    getSettings(request) {
        let settings = request.saveAs || {};
        settings = (0, lodash_defaultsdeep_1.default)({}, settings, this.defaults);
        return settings;
    }
    getFileName(file) {
        let extension = path.extname(file);
        return path.basename(file, extension);
    }
    async saveAsFile(data, outputDir, fileName, extension, logger) {
        let absoluteOutputDir = path.resolve(process.cwd(), outputDir);
        const outputPath = path.resolve(absoluteOutputDir, fileName + extension);
        await mkdirp(absoluteOutputDir);
        await new Promise((resolve, reject) => {
            fs.writeFile(outputPath, data, function (err) {
                if (err) {
                    reject(err);
                }
                logger.log("verbose", "Saved " + absoluteOutputDir + "/" + fileName + extension);
                resolve();
            });
        });
        return outputPath;
    }
}
exports.SaveAsFilePlugin = SaveAsFilePlugin;
//# sourceMappingURL=SaveAsFilePlugin.js.map