@plumjs/plumier/lib/binder.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const core_1 = require("@plumjs/core");
const reflect_1 = require("@plumjs/reflect");
const debug_1 = tslib_1.__importDefault(require("debug"));
const log = debug_1.default("plum:binder");
function createConversionError(value, prop) {
    const type = Array.isArray(prop.parameterType) ? `Array<${prop.parameterType[0].name}>` : prop.parameterType.name;
    log(`[Converter] Unable to convert ${core_1.b(value)} into ${core_1.b(type)}`);
    return new core_1.ConversionError({ path: prop.path, type, value }, core_1.errorMessage.UnableToConvertValue.format(value, type, prop.path.join("->")));
}
function flattenConverters(converters) {
    return converters.reduce((a, b) => { a.set(b.type, b.converter); return a; }, new Map());
}
exports.flattenConverters = flattenConverters;
//some object can't simply convertible to string https://github.com/emberjs/ember.js/issues/14922#issuecomment-278986178
function safeToString(value) {
    try {
        return value.toString();
    }
    catch (e) {
        return "[object Object]";
    }
}
/* ------------------------------------------------------------------------------- */
/* ------------------------------- CONVERTER ------------------------------------- */
/* ------------------------------------------------------------------------------- */
function booleanConverter(rawValue, prop) {
    const value = safeToString(rawValue);
    const list = {
        on: true, true: true, "1": true, yes: true,
        off: false, false: false, "0": false, no: false
    };
    const result = list[value.toLowerCase()];
    log(`[Boolean Converter] Raw: ${core_1.b(value)} Value: ${core_1.b(result)}`);
    if (result === undefined)
        throw createConversionError(value, prop);
    return result;
}
exports.booleanConverter = booleanConverter;
function numberConverter(rawValue, prop) {
    const value = safeToString(rawValue);
    const result = Number(value);
    if (isNaN(result) || value === "")
        throw createConversionError(value, prop);
    log(`[Number Converter] Raw: ${core_1.b(value)} Value: ${core_1.b(result)}`);
    return result;
}
exports.numberConverter = numberConverter;
function dateConverter(rawValue, prop) {
    const value = safeToString(rawValue);
    const result = new Date(value);
    if (isNaN(result.getTime()) || value === "")
        throw createConversionError(value, prop);
    log(`[Date Converter] Raw: ${core_1.b(value)} Value: ${core_1.b(result)}`);
    return result;
}
exports.dateConverter = dateConverter;
function defaultModelConverter(value, prop) {
    //--- helper functions
    const isConvertibleToObject = (value) => {
        if (typeof value == "boolean" ||
            typeof value == "number" ||
            typeof value == "string")
            return false;
        else
            return true;
    };
    //---
    //if the value already instance of the type then return immediately
    //this is possible when using decorator binding such as @bind.request("req")
    if (value instanceof prop.parameterType)
        return value;
    //get reflection metadata of the class
    const reflection = reflect_1.reflect(prop.parameterType);
    //check if the value is possible to convert to model
    if (!isConvertibleToObject(value))
        throw createConversionError(value, prop);
    log(`[Model Converter] converting ${core_1.b(value)} to ${core_1.b(prop.parameterType.name)}{${core_1.b(reflection.ctorParameters.map(x => x.name).join(", "))}}`);
    //sanitize excess property to prevent object having properties that doesn't match with declaration
    //traverse through the object properties and convert to appropriate property's type
    const sanitized = reflection.ctorParameters.map(x => ({
        name: x.name,
        value: convert(value[x.name], {
            parameterType: x.typeAnnotation,
            path: prop.path.concat(x.name),
            decorators: x.decorators,
            converters: prop.converters
        })
    })).reduce((a, b) => { a[b.name] = b.value; return a; }, {});
    log(`[Model Converter] Sanitized value ${core_1.b(sanitized)}`);
    //crete new instance of the type and assigned the sanitized values
    try {
        return Object.assign(new prop.parameterType(), sanitized);
    }
    catch (e) {
        const message = core_1.errorMessage.UnableToInstantiateModel.format(prop.parameterType.name);
        if (e instanceof Error) {
            e.message = message + "\n" + e.message;
            throw e;
        }
        else
            throw new Error(message);
    }
}
exports.defaultModelConverter = defaultModelConverter;
function defaultArrayConverter(value, prop) {
    if (!Array.isArray(value))
        throw createConversionError(value, prop);
    log(`[Array Converter] converting ${core_1.b(value)} to Array<${prop.parameterType[0].name}>`);
    return value.map(((x, i) => convert(x, {
        path: prop.path.concat(i.toString()),
        converters: prop.converters,
        decorators: [],
        parameterType: prop.parameterType[0]
    })));
}
exports.defaultArrayConverter = defaultArrayConverter;
exports.DefaultConverterList = [
    { type: Number, converter: numberConverter },
    { type: Date, converter: dateConverter },
    { type: Boolean, converter: booleanConverter }
];
function convert(value, prop) {
    if (value === null || value === undefined)
        return undefined;
    if (!prop.parameterType)
        return value;
    log(`[Converter] Path: ${core_1.b(prop.path.join("->"))} ` +
        `Source Type: ${core_1.b(typeof value)} ` +
        `Target Type:${core_1.b(prop.parameterType)} ` +
        `Value: ${core_1.b(value)}`);
    //check if the parameter contains @array()
    if (Array.isArray(prop.parameterType))
        return defaultArrayConverter(value, Object.assign({}, prop, { parameterType: prop.parameterType }));
    //check if parameter is native value that has default converter (Number, Date, Boolean) or if user provided converter
    else if (prop.converters.has(prop.parameterType))
        return prop.converters.get(prop.parameterType)(value, Object.assign({}, prop, { parameterType: prop.parameterType }));
    //if type of model and has no  converter, use DefaultObject converter
    else if (core_1.isCustomClass(prop.parameterType))
        return defaultModelConverter(value, Object.assign({}, prop, { parameterType: prop.parameterType }));
    //no converter, return the value
    else
        return value;
}
exports.convert = convert;
/* ------------------------------------------------------------------------------- */
/* ----------------------------- BINDER FUNCTIONS -------------------------------- */
/* ------------------------------------------------------------------------------- */
function bindModel(action, request, par, converter) {
    if (!par.typeAnnotation)
        return;
    if (!core_1.isCustomClass(par.typeAnnotation))
        return;
    log(`[Model Binder] Action: ${core_1.b(action.name)} Parameter: ${core_1.b(par.name)} Parameter Type: ${core_1.b(par.typeAnnotation.name)}`);
    log(`[Model Binder] Request Body: ${core_1.b(request.body)}`);
    return converter(request.body);
}
function bindDecorator(action, request, par, converter) {
    const decorator = par.decorators.find((x) => x.type == "ParameterBinding");
    if (!decorator)
        return;
    log(`[Decorator Binder] Action: ${core_1.b(action.name)} Parameter: ${core_1.b(par.name)} Decorator: ${core_1.b(decorator.name)} Part: ${core_1.b(decorator.part)}`);
    const getDataOrPart = (data) => decorator.part ? data && data[decorator.part] : data;
    switch (decorator.name) {
        case "Body":
            return converter(getDataOrPart(request.body));
        case "Query":
            return converter(getDataOrPart(request.query));
        case "Header":
            return converter(getDataOrPart(request.headers));
        case "Request":
            return converter(getDataOrPart(request));
    }
}
function bindArrayDecorator(action, request, par, converter) {
    if (!Array.isArray(par.typeAnnotation))
        return;
    log(`[Array Binder] Action: ${core_1.b(action.name)} Parameter: ${core_1.b(par.name)} Type: ${core_1.b(par.typeAnnotation)}`);
    return converter(request.body, par.typeAnnotation);
}
function bindRegular(action, request, par, converter) {
    log(`[Regular Binder] Action: ${core_1.b(action.name)} Parameter: ${core_1.b(par.name)} Value: ${core_1.b(request.query[par.name])}`);
    return converter(request.query[par.name.toLowerCase()]);
}
function bindParameter(request, action, converter) {
    const mergedConverters = flattenConverters(exports.DefaultConverterList.concat(converter || []));
    return action.parameters.map(((x, i) => {
        const converter = (result, type) => convert(result, {
            path: [x.name], parameterType: type || x.typeAnnotation,
            converters: mergedConverters, decorators: x.decorators
        });
        return bindArrayDecorator(action, request, x, converter) ||
            bindDecorator(action, request, x, converter) ||
            bindModel(action, request, x, converter) ||
            bindRegular(action, request, x, converter);
    }));
}
exports.bindParameter = bindParameter;