json-mapper-json

    1.3.3 • Public • Published

    json-mapper-json

    Simple library to convert a json object into a new json object formatted by a template.

    Installation

    Install via npm:

    $ npm install json-mapper-json
    

    Documentation

    Usage

    const jsonMapper = require('json-mapper-json');
     
    jsonMapper(json<Object>, template<Object>) => Promise

    Template Syntax Explanations

    {
      newFieldName1: {
        path: <String>, // required
        required: <Boolean> // not required, default `true`
        formatting: <Function> // optional (ex: function(value) {return value + '_formatted';})
        defaultValue: <AnyType> // optional
        type: <NativeType> // optional (ex: String, Number, Boolean, ...) (not supported yet)
        nested: { <Object> // optional
          newNestedFieldName: <String>,
          required: <Boolean> // not required, default `true`
          formatting: <Function> // optional
          defaultValue: <AnyType> // optional
          type: <NativeType> // optional (ex: String, Number, Boolean, ...) (not supported yet)
          nested: { <Object> // optional
            ...
          },
        },
      },
      newFieldName2: <String> // (it's the path, syntactic sugar for {path: ''})
      ...
    }

    Path Key Words

    • $root: give possibility to access the root given object in a nested path.
    • $item: give possibility to access of the all item of an array in a nested path.
    • $empty: give possibility to create skip path, to create empty object to be able to merge paths (see example).

    Example

    Basic

    jsonMapper({
      field: 'value',
    }, {
      'new_field': {
        path: 'field',
      },
    }).then((result) => {
      /*
      result === {
        'new_field': 'value',
      }
      */
    });

    Basic with required

    jsonMapper({
      field1: 'value1',
    }, {
      'new_field1': {
        path: 'field1',
      },
      'new_field2': {
        path: 'field2',
        required: false,
      },
    }).then((result) => {
      /*
      result === {
        'new_field1': 'value1',
      }
      */
    });

    Basic with defaultValue

    jsonMapper({
      field1: 'value1',
    }, {
      'new_field1': {
        path: 'field1',
      },
      'new_field2': {
        path: 'field2',
        defaultValue: 'default_value',
      },
    }).then((result) => {
      /*
      result === {
        'new_field1': 'value1',
        'new_field2': 'default_value',
      }
      */
    });
    jsonMapper({
      field1: 'value1',
      nested: {
        field3: 'value3',  
      },
    }, {
      'new_field1': {
        path: 'field1',
      },
      'new_field2': {
        path: 'field2',
      },
    }).then((result) => {
      /*
      throw Error: Invalid path nested.field2 (field2)
      */
    });

    Basic with nested

    jsonMapper({
      field1: {
        field2: {
          field3: 'value',
          field4: 'value4',
        },
      },
    }, {
      'new_field': {
        path: 'field1.field2',
        nested: {
          'nested_field1': {
            path: 'field3',
          },
          'nested_field2': {
            path: 'field4',
          },
        },
      },
    }).then((result) => {
      /*
      result === {
        'new_field': {
          'nested_field1': 'value',
          'nested_field2': 'value4',
        }
      }
      */
    });

    Basic with formatting

    jsonMapper({
      field1: {
        field2: {
          field3: 'value',
        },
      },
    }, {
      'new_field': {
        path: 'field1.field2.field3',
        formatting: (value) => {return value + '_formatted';},
      },
    }).then((result) => {
      /*
      result === {
        'new_field': 'value_formatted',
      }
      */
    });

    Array

    jsonMapper([{
      field: 'value1',
    }, {
      field: 'value2',
    }, {
      field: 'value3',
    },
    ], {
      'new_field': {
        path: 'field',
      },
    }).then((result) => {
      /*
      result === [
        {'new_field': 'value1'},
        {'new_field': 'value2'},
        {'new_field': 'value3'},
      ]
      */
    });

    Array with formatting

    jsonMapper([{
      field: 'value1',
    }, {
      field: 'value2',
    }, {
      field: 'value3',
    },
    ], {
      'new_field': {
        path: 'field',
        formatting: (value, index) => (`${value}_formatted_${index}`),
      },
    }).then((result) => {
      /*
      result === [
        {'new_field': 'value1_formatted_0'},
        {'new_field': 'value2_formatted_1'},
        {'new_field': 'value3_formatted_2'},
      ]
      */
    });

    Usage of the syntactic sugar for path

    jsonMapper({
      field: 'value',
    }, {
      'new_field': 'field',
    }).then((result) => {
      /*
      result === {
        'new_field': 'value',
      }
      */
    });

    Array with nested and path syntactic sugar

    jsonMapper([{
      field: {'nested_field': 'value1'},
    }, {
      field: {'nested_field': 'value2'},
    }, {
      field: {'nested_field': 'value3'},
    },
    ], {
      'new_field': {
        path: 'field',
        nested: {
          'new_nested_field': 'nested_field',
        },
      },
    }).then((result) => {
      /*
      result === [
        {'new_field': {'new_nested_field': 'value1'}},
        {'new_field': {'new_nested_field': 'value2'}},
        {'new_field': {'new_nested_field': 'value3'}},
      ]
      */
    });

    Usage of the key word $root for path

    jsonMapper({
      'content': {
        'result': [
          {
            'courseStatisticsDto': {
              'times': 3,
              'persons': 1,
              'courseCode': '',
            },
            'courseAddressDto': {},
            'endDate': 1460590552000,
            'startDate': 1460590552000,
            'name': 'Example Course',
          },
        ],
        'type': 'offline',
      },
    }, {
      data: {
        path: 'content.result',
        nested: {
          name: 'name',
          code: 'courseStatisticsDto.courseCode',
          type: '$root.content.type',
        },
      },
    }).then((result) => {
    /*
      result === {
        'data': [{
          'name': 'Example Course',
          'code': '',
          'type': 'offline',
        }],
      }
    */
    });

    Usage of the key word $item for path

    jsonMapper({
        hits: {
            total: 1,
            hits: [{
                _index: 'some_index',
                _type: 'some_type',
                _id: '123456',
                _score: 1,
                _source: {
                    id: 123456
                },
            }],
        },
    }, {
        hits: {
            path: 'hits.hits',
            nested: {
                id: '_source.id',
                type: {
                    path: '$item',
                    formatting: (value, index) => (`${value._index}/${value._type}/${index}`),
                },
            },
        },
    }).then((result) => {
    /*
      result === {
        'hits': [{
          'id': 123456,
          'type': 'some_index/some_type/0',
        }],
      }
    */
    });

    Usage of the key word $empty for path

    jsonMapper({
      field1: {
        field2: {
          field3: 0
        },
        field4: {
          field5: ['value1', 'value2'],
        },
      },
    }, {
      'new_field1': {
        path: 'field1',
        nested: {
          'new_field2': {
            path: '$empty',
            nested: {
              new_field3: {
                path: 'field2.field3'
              },
              new_field4: {
                path: 'field4.field5',
              },
            },
          },
        },
      },
    }).then((result) => {
      /*
      {
        new_field1: {
          new_field2: {
            new_field3: 0,
            new_field4: ['value1', 'value2'],
          },
        },
      }
      */
    });
     
    ## Note
     
    this library is very usefull when you have well design models and have to communicate with horrible webservices.
     
    ## TODO
     
    * manage `type` property
     
    ## Contributing
     
    This project is a work in progress and subject to API changes, please feel free to contribute

    Install

    npm i json-mapper-json

    DownloadsWeekly Downloads

    400

    Version

    1.3.3

    License

    MIT

    Unpacked Size

    104 kB

    Total Files

    7

    Last publish

    Collaborators

    • marchah