best practice to standardize data in JSON objects in a flexible way - json

Question

I need to convert information in various structured formats to other formats (e.g. html or text) using NodeJS. So I took the approach to convert the source format to JSON based on JSON-Schemas. I can also convert the resulting JSON to text based on Pug templates.
What I'm now looking for is a flexible way to standardise the data and simplify the structures in the JSON so there are less variations in e.g. the date and time format.
An example of such object would be:
{
header: {
sender: {
// more properties
id: '12345';
}
receiver: {
// more properties
id: '987654';
}
date: {
date: '170910',
time: '0922'
}
// more properties
}
// more properties
someMore: {
birthdate: {
year: 2016,
month: 5,
day: 11
}
otherProperty: {
// more properties
date: '20170205'
}
}
}
I'd like to convert this to
{
header: {
senderId: '12345',
receiverId: '987654'
date: '20170910T0922'
}
// more properties
someMore: {
birthdate: '20160511',
otherProperty: {
// more properties
date: '20170205'
}
}
}
The idea is to recursively loop over all properties in the object and use a Map that has een entry for every property that should be acted on, e.g.
var map = new Map();
map.set('sender', getSender());
map.set('date', normalizeDate());
map.set('birthdate', normalizeDate());
for each property key the map is checked and if it returns a function, the function is executed, if not
the property is created and the loop goes on.
However, I get the distinct impression this problem has been solved before, so I wonder if there are npm packages I could use instead?

Answer 1

After searching some more and trying out different JSON transformers I settled on dot-object because it provides a simple way to transform part of the structure with multiple 'rules' in one go.
I gave up on the idea of writing a lot of general normalizing functions and just settled for the most obvious ones (gender and date/time) and handled them by transforming the various structures to a single standardized structure and then apply the appropriate function.
This might not be the most elegant approach but I'm time constraint and this works.
To convert the source to the result as described in the question, this code was used:
const dot = require('dot-object');
const rules = {
'header.sender.id': 'header.senderId',
'header.receiver.id': 'header.receiverId'
};
const target = {};
dot.transform(rules, src, target);
// normalizing
target.date = normalizeDate(target.date);
target.someMore.birthdate = normalizeDate(target.someMore.birthdate);
target.someMore.otherProperty.date = normalizeDate(target.someMore.otherProperty.date);