native-json-transform

Restructuring and performing operations on JSON on the fly for NodeJS.

Background

This is a fork version form original node-json-transform.
The difference about this with original version is that we already removed Lodash dependencies. So this library has no dependencies anymore. That is why we call it native-json-transform.

Note:

• Code slightly different with original but all features is same.
• Minimum requirement NodeJS 6.

Install use NPM

$ npm install native-json-transform

Usage

Basic Example

var JsonTransform = require("native-json-transform").JsonTransform;

First we need some data.

var data = {
    posts : [
        {
            title : "title1",
            description: "description1",
            blog: "This is a blog.",
            date: "11/4/2013",
            extra : {
                link : "http://goo.cm"
            },
            list1:[
                {
                    name:"mike"
                }
            ],
            list2:[
                {
                    item: "thing"
                }
            ],
            clearMe: "text"
        }
    ]
};

The map defines how the output will be structured and which operations to run.

var map = {
    list : 'posts',
    item: {
        name: "title",
        info: "description",
        text: "blog",
        date: "date",
        link: "extra.link",
        item: "list1.0.name",
        clearMe: "",
        fieldGroup: ['title', 'extra']
    },
    operate: [
        {
            run: "Date.parse", on: "date"
        },
        {
            run: function(val) { return val + " more info"}, on: "info"
        }
    ],
    each: function(item){
        // make changes
        item.iterated = true;
        return item;
    }
}
};

You can read this as follows:

• Get the array of objects in "posts".
• Map the name to title, info to description etc.
• Run Data.parse on the date value.
• Run each function on all items after mapping and operations.

Run it synchronously

var jsonTransform = JsonTransform(data, map);
var result = jsonTransform.make();
console.log(result);

... or asynchronously

var jsonTransform = JsonTransform(data, map);
var promise = jsonTransform.makeAsync();
promise.then((function(result){
    console.log(result);
});

The expected output.

[
    {
        name : "title1",
        info: "description1",
        text: "This is a blog.",
        date: 1383544800000,
        link: "http://goo.cm",
        info: "mike more info",
        clearMe: "",
        fieldGroup: ['title1', { link : "http://goo.cm" }],
        iterated: true
    }
]

Advanced Example

var map = {
    list: 'items',
    item: {
        id: 'id',
        sku: 'sku',
        zero: 'zero',
        toReplace: 'sku',
        errorReplace: 'notFound',
        simpleArray: ['id', 'sku','sku'],
        complexArray: [ {node: 'id'} , { otherNode:'sku' } , {toReplace:'sku'} ],
        subObject: {
            node1: 'id',
            node2: 'sku',
            subSubObject: {
                node1: 'id',
                node2: 'sku',
            }
        },
        remove: ['unwanted']
    },
    defaults: {
        "missingData": true
    },
    operate: [
        {
            run: (val) => 'replacement',
            on: 'subObject.subSubObject.node1'
        },
        {
            run: (val) => 'replacement',
            on: 'errorReplace'
        },
        {
            run: (val) => 'replacement',
            on: 'toReplace'
        },
            {
            run: (val) => 'replacement',
            on: 'simpleArray.2'
        },
        {
            run: (val) => 'replacement',
            on: 'complexArray.2.toReplace'
        }
    ]
};

var object = {
    items:[
        {
            id: 'books',
            zero: 0,
            sku:'10234-12312',
            unwanted: true
        }
    ]
};

var result = JsonTransform(data, map).make();

The expected output.

[
    {
        "id": "books",
        "sku": "10234-12312",
        "zero": 0,
        "toReplace": "replacement",
        "errorReplace": "replacement",
        "simpleArray": [
            "books",
            "10234-12312",
            "replacement"
        ],
        "complexArray": [
            {
                "node": "books"
            },
            {
                "otherNode": "10234-12312"
            },
            {
                "toReplace": "replacement"
            }
        ],
        "subObject": {
            "node1": "books",
            "node2": "10234-12312",
            "subSubObject": {
                "node1": "replacement",
                "node2": "10234-12312"
            }
        },
        "missingData": true
    }
]

Multi-template Example

var data = {
    products: [{
        id: 'books0',
        zero: 0,
        sku: '00234-12312',
        subitems: [
            { subid: "0.0", subsku: "subskuvalue0.0" },
            { subid: "0.1", subsku: "subskuvalue0.1" }
        ]
    }, {
        id: 'books1',
        zero: 1,
        sku: '10234-12312',
        subitems: [
            { subid: "1.0", subsku: "subskuvalue1.0" },
            { subid: "1.1", subsku: "subskuvalue1.1" }
        ]
    }]
};

var baseMap = {
    'list': 'products',
    'item' : {
        'myid': 'id',
        'mysku': 'sku',
        'mysubitems': 'subitems'
    },
    operate: [
        {
            'run': function(ary) { 
            	return JsonTransform({list:ary}, nestedMap).make();
            }, 
            'on': 'mysubitems'
        }
    ]
};

var nestedMap = {
    'list': 'list',
    'item' : {
        'mysubid': 'subid',
        'mysubsku': 'subsku'
    }
};

var result = JsonTransform(data, baseMap).make();

The expected output.

[
    {
        "myid": "books0",
        "mysku": "00234-12312",
        "mysubitems": [
        	{ "mysubid": "0.0", "mysubsku": "subskuvalue0.0" }, 
        	{ "mysubid": "0.1", "mysubsku": "subskuvalue0.1"}
        ]
    }, 
    {
        "myid": "books1",
        "mysku": "10234-12312",
        "mysubitems": [
        	{ "mysubid": "1.0", "mysubsku": "subskuvalue1.0" }, 
        	{ "mysubid": "1.1", "mysubsku": "subskuvalue1.1" }
        ]
    }
]

Context Example

First we need some data.

    var data = {
        posts : [
            {
                title : "title1",
                description: "description1"
            }
        ]
    };

The map defines how the output will be structured and which operations to run.

    var map = {
        list : 'posts',
        item: {
            name: "title",
            info: "description"
        },
        operate: [
            {
                run: function(val, context) { return val + " more info for" + context.type},
                on: "info"
            }
        ],
        each: function(item, index, collection, context){
            // make changes
            item.type = context.type;
            return item;
        }
    };

Run it

    var jsonTransform = JsonTransform(data, map);
    var context = { type: 'my-type' };
    var result = jsonTransform.make(context);
    console.log(result);

The expected output.

    [
        {
            name : "title1",
            info: "description1 more info for my-type",
            type: 'my-type'
        }
    ]

Enjoy!

Unit Test

Unit test has been replaced from jasmine-node to mocha for better unit test.

$ npm test