json-data-mapper/lib/index.js

Json Mapper Utility to transform Json to required format based on the schema given.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JsonMapper = void 0;
const types_1 = require("./types");
class JsonMapper {
    static formatToSchema(schema, data) {
        if (this.invalidSchema(schema) || !data) {
            return;
        }
        if (schema.data) {
            data = data[schema.data];
        }
        if (this.checkIfSchemaIsList(schema)) {
            return this.formatAsList(schema.format, data);
        }
        else {
            return this.formatAsObj(schema.format, data);
        }
    }
    /*
    * Mapper to format Json to Object schema.
    */
    static formatAsObj(schema, data) {
        if (Array.isArray(data)) {
            data = data[0]; // Taking 1st object in array if data passed is array and schema is not list.
        }
        const keys = Object.keys(schema);
        return this.formatter(keys, schema, data);
    }
    /*
    * Mapper to format Json to List schema.
    */
    static formatAsList(schema, data) {
        if (!Array.isArray(data)) {
            data = [data];
        }
        const keys = Object.keys(schema);
        return data.map((item) => {
            return this.formatter(keys, schema, item);
        });
    }
    /*
     * Processor Function which returns single transformed object.
    */
    static formatter(keys, schema, data) {
        const regex = /\$/g;
        let obj = {};
        keys.forEach((key) => {
            let dataField = schema[key].sourceField;
            if (schema[key].type && schema[key].type.toUpperCase() === types_1.Types.FUNCTION) {
                dataField = new Function(`return ${dataField}`)();
                obj = Object.assign(Object.assign({}, obj), { [key]: this.transformFn(dataField, this.getParamsForTransformFn(dataField, data)) });
            }
            else {
                if (Array.isArray(dataField)) {
                    const item = JSON.stringify(dataField);
                    const mapFields = JSON.parse(item.replace(/\$/g, ""));
                    obj = Object.assign(Object.assign({}, obj), { [key]: this.mapMultipleFields(mapFields, data) });
                }
                else {
                    const mapField = dataField.replace(regex, "");
                    obj = Object.assign(Object.assign({}, obj), { [key]: data[mapField] });
                }
            }
        });
        return obj;
    }
    static invalidSchema(schema) {
        return !schema || !schema.format;
    }
    static checkIfSchemaIsList(schema) {
        return schema.isList;
    }
    static mapMultipleFields(fields, item) {
        const dataset = [];
        fields.forEach((ele) => {
            if (ele instanceof Function) {
                dataset.push(this.transformFn(ele, this.getParamsForTransformFn(ele, item)));
            }
            else {
                dataset.push(item[ele]);
            }
        });
        return dataset;
    }
    static getParamsForTransformFn(fn, data) {
        return this.getParameterNames(fn).map((param) => {
            return data[param];
        });
    }
    static transformFn(fn, params) {
        return fn.apply(fn, params);
    }
    static getParameterNames(fn) {
        const code = fn.toString().replace(this.COMMENTS, '').replace(this.FAT_ARROWS, '').replace(this.DEFAULT_PARAMS, '');
        const result = code.slice(code.indexOf('(') + 1, code.indexOf(')')).match(/([^\s,]+)/g);
        return result === null ? [] : result;
    }
}
exports.JsonMapper = JsonMapper;
JsonMapper.COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
JsonMapper.DEFAULT_PARAMS = /=[^,]+/mg;
JsonMapper.FAT_ARROWS = /=>.*$/mg;