@fdm-monster/server/dist/middleware/param-converter.middleware.js

FDM Monster is a bulk OctoPrint manager to set up, configure and monitor 3D printers. Our aim is to provide extremely optimized websocket performance and reliability.

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    ParamBool: function() {
        return ParamBool;
    },
    ParamId: function() {
        return ParamId;
    },
    ParamInt: function() {
        return ParamInt;
    },
    ParamString: function() {
        return ParamString;
    }
});
const _containertokens = require("../container.tokens");
const _validators = require("../handlers/validators");
const _genericvalidation = require("../controllers/validation/generic.validation");
const _lodash = require("lodash");
const ParamInt = (paramName)=>createParamDecorator(paramName, Number);
const ParamBool = (paramName)=>createParamDecorator(paramName, Boolean);
const ParamString = (paramName)=>createParamDecorator(paramName, String);
const ParamId = (paramName)=>createParamDecorator(paramName, "id");
function createParamDecorator(paramName, type) {
    return async (req, res, next)=>{
        const paramValue = req.params[paramName];
        if (paramValue === undefined) {
            return res.status(400).send(`Missing parameter: ${paramName}`);
        }
        let convertedValue;
        const isTypeormMode = req.container?.resolve(_containertokens.DITokens.isTypeormMode);
        let validateIdAsType = null;
        if (type === "id") {
            validateIdAsType = isTypeormMode ? Number : String;
        }
        if (type === Boolean) {
            if (paramValue.toLowerCase() === "true") {
                convertedValue = true;
            } else if (paramValue.toLowerCase() === "false") {
                convertedValue = false;
            } else {
                return res.status(400).send(`Invalid boolean: ${paramName}`);
            }
        } else if (type === Number || validateIdAsType === Number) {
            convertedValue = parseInt(paramValue, 10);
            if (isNaN(convertedValue)) {
                return res.status(400).send(`Invalid number: ${paramName}`);
            }
        } else if (type === String || validateIdAsType === String) {
            convertedValue = paramValue;
            if (!(0, _lodash.isString)(convertedValue)) {
                return res.status(400).send(`Invalid string: ${paramName}`);
            }
        } else {
            return res.status(400).send(`Unknown type of: ${paramName}`);
        }
        if (validateIdAsType === String || validateIdAsType === Number) {
            try {
                await (0, _validators.validateInput)({
                    id: convertedValue
                }, (0, _genericvalidation.idRulesV2)(isTypeormMode));
            } catch (e) {
                return next(e);
            }
        }
        req.local = req.local || {};
        req.local[paramName] = convertedValue;
        next();
    };
}

//# sourceMappingURL=param-converter.middleware.js.map