json-mapping version 1.1.4 (latest)

My mappingtable contains two elements in "values"-array:

[
  {
    "oldKey": "mykey",
    "newKey": "myNewKey",
    "values": [
      {
        "oldValue": 1,
        "newValue": "Number 1"
      },
      {
        "oldValue": 2,
        "newValue": "Number 2"
      }
    ]
  }
]

But the values were only replaced, if there is a match in the 2nd element.

Example:

• Result for a JSON { "mykey": 1} will be empty => {}
• But a JSON { "mykey": 2} will be mapped/replaced correctly to { myNewKey: 'Number 2' }

So how is it possible to replace more than one value?

Complete code:

const mapping = require('json-mapping');

let json1 = {
       "mykey": 1
};

let json2 = {
       "mykey": 2
}

let mappingtable = [
    {
        oldKey: "mykey",
        newKey: "myNewKey",
        values: [ {"oldValue": 1, "newValue": "Number 1" },{ "oldValue": 2, "newValue": "Number 2" }]
    }
];

let result1 = mapping.map(json1, mappingtable);
let result2 = mapping.map(json2, mappingtable);

console.log("result 1:");
console.log(result1);
console.log("result 2:");
console.log(result2);

Result:

node test.js

result 1:
{}
result 2:
{ myNewKey: 'Number 2' }

Was wondering if you knew of a way to express flattening and consolidating a JSON data structure with how your script is currently implemented. Instead of mapping actual data, the goal is to essentially map schema. For example, I have a current schema which includes keys to express the types of nested data.

{
  history: {
    approved: {
      modification: [
        {
          dateTime: "",
          userDisplayName: "",
          userDn: ""
        }
      ]
    },
    broughtUnderEdit: {
      modification: [
        {
          dateTime: "",
          userDisplayName: "",
          userDn: ""
        }
      ]
    },
    changed: {
      modification: [
        {
          dateTime: "",
          userDisplayName: "",
          userDn: ""
        }
      ]
    },
    created: {
      dateTime: "",
      userDisplayName: "",
      userDn: ""
    },
    projectId: "",
    projectName: "",
    projectType: ""
  }
}

The goal is to reduce the levels of data hierarchy and create a result like this:

{
  "history": [
    { 
      "projectId": "",
      "projectName": "",
      "projectType": "",
      "dateTime":"",
      "type": ["approved", "broughtUnderEdit", "changed", "created"],
      "userDisplayName": "",
      "userDn": ""
    }
  ]
}

The closest thing I can create relies heavily on rewriting the value and doesn't explicitly define the mapping of all the keys other than approved. Here's the example:

const flattened = mapping.map(orig, [
  {
    oldKey: "history.approved.modification[0]",
    newKey: "history",
    values: [
      {
        oldValue: orig.history.approved.modification[0],
        newValue: [
          _.merge(orig.history.approved.modification[0], {
            type: ["approved", "changed", "broughtUnderEdit", "created"],
            projectId: orig.history.projectId,
            projectName: orig.history.projectName,
            projectType: orig.history.projectType
          })
        ]
      }
    ]
  }
]);

I'm thinking the answer is no but was curious if you knew a way to make it work without modifying the code. Thanks for any input!

There's also a sandbox here: https://codesandbox.io/embed/k9rmnlwmm7

Right now, we have to make it a 2 step process:

json = mapping.map(json, [
		{
			oldKey: 'object1.bool',
			newKey: 'object1.boo'
		},
		
		{
			oldKey: 'object1.boo',
			newKey: 'object1.bool',
			values: [{
				oldValue: true,
				newValue: false
			}]
	    }]);

In these cases, we should simply replace the key values. Right now, the old key is removed and a new key is added at the end of the json object.