Data Manipulator
Data Manipulator is a library that helps you to manipulate all none Primitive data types.
Getting Started
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.
Installing
npm install data-manipulator
Requiring library
const { DM } = require("data-manipulator");
Predefine configurations
Important! With this option enabled function Set(data) will copy data to a newData via JSON.parse(JSON.stringify(object)). Therefore, the newData returned from Get() will be stingified!
const dataManipulator = new DM();
or
const dataManipulator = new DM({
enableDeepCopy: true
});
Will not override input data
const dataManipulator2 = new DM({
enableDeepCopy: false
});
Replace:
Function that search strings by given regular expression and manipulates them to something new.
An example for an actual usage in the tests layer: By warping all arrays that contains mongo documents to a one huge object. As a result all the fake data gets manipulated into data that is valid for mongo insert.
dataManipulator2
.Set({ fakeFactorySpecialRequestsArray, fakeUsersArray, fakeTasksArray })
.Replace(DM.MongoIdRGX, (id) => mongoHelper.toObjectID(id))
.Replace(DM.ISODateRGX, (date) => moment.tz(date, 'Asia/Jerusalem').toDate())
DeepSort:
Function that sorts data via schema. (follow the examples in order to understand better)
const outputData = dataManipulator
.Set(inputData)
.DeepSort(sortSchema)
.Get();
sortByField: What field to sort.
const outputData = dataManipulator
.Set([5.5, "5.4", "av", 9.99])
.DeepSort({
sortByField: DM.PrimitiveValue
})
.Get();
outputData: ["5.4", 5.5, 9.99, "av"]
const outputData = dataManipulator
.Set([{ number: 7 }, { number: 2 }, { number: 5 }])
.DeepSort({
sortByField: "number"
})
.Get();
outputData: [{ number: 2 }, { number: 5 }, { number: 7 }]
fieldName & sortDataArray: Where to sort.
const outputData = dataManipulator
.Set({
values: [5, 2, 7]
})
.DeepSort({
fieldName: "values",
sortByField: DM.PrimitiveValue
})
.Get();
outputData: {
values: [2, 5, 7]
}
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [26, 7, 23], anotherValue: 4 },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 },
{ value: "B", numbers: [2,5,1], anotherValue: "C" },
])
.DeepSort({
sortByField: ["value", "anotherValue"],
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
})
.Get();
outputData: [
{ numbers: [1,2,5], value: 5 },
{ numbers: [1,2,5], value: 8 },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4 },
{ value: "B", numbers: [1,2,5], anotherValue: "C" },
]
const outputData = dataManipulator
.Set([
{ numbers: [2,5,1] },
{ numbers: [2,5,1] },
{ numbers: [2,5,1] }
])
.DeepSort({
sortDataArray: [{
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}]
})
.Get();
outputData: [
{ numbers: [1,2,5] },
{ numbers: [1,2,5] },
{ numbers: [1,2,5] }
]
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [2,5,1] },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 }
])
.DeepSort({
sortByField: "value",
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
})
.Get();
outputData: [
{"value":5,"numbers":[1,2,5]},
{"numbers":[1,2,5],"value":8},
{"numbers":[1,2,5],"value":"B"}
]
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [2,5,1] },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 }
])
.DeepSort([{
fieldName: 0,
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
},{
sortByField: "value",
}])
.Get();
outputData: [
{"value":5,"numbers":[2,5,1]},
{"numbers":[2,5,1],"value":8},
{"numbers":[1,2,5],"value":"B"}
]
const outputData = dataManipulator
.Set({
name: {
values: [5, 2, 7]
}
})
.DeepSort({
fieldName: "name",
sortDataArray: {
fieldName: "values",
sortByField: DM.PrimitiveValue
}
})
.Get();
outputData: {
name: {
values: [2, 5, 7]
}
}
const outputData = dataManipulator
.Set({
name: {
values: [{ number: 7 }, { number: 2 }, { number: 5 }]
}
})
.DeepSort({
fieldName: "name",
sortDataArray: {
fieldName: "values",
sortByField: "number"
}
})
.Get();
outputData: {
name: {
values: [{ number: 2 }, { number: 5 }, { number: 7 }]
}
}
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "5" },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "8" },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "FEWF" },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "5.14" },
{ value: "B", numbers: [2,5,1], anotherValue: "C" },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "8" },
])
.DeepSort({
sortByField: ["value", "anotherValue", "thirdValue"],
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
})
.Get();
outputData: [
{ numbers: [1,2,5], value: 5 },
{ numbers: [1,2,5], value: 8 },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "5" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "5.14" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "8" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "8" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "FEWF" },
{ value: "B", numbers: [1,2,5], anotherValue: "C" },
]
const outputData = dataManipulator
.Set([{ value: "B", numbers: [2,5,1] }, { numbers: [2,5,1], value: 8 }, { numbers: [2,5,1], value: 5 }])
.DeepSort([{
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
},{
sortByField: "value",
}])
.Get();
outputData: [{"value":5,"numbers":[1,2,5]},{"numbers":[1,2,5],"value":8},{"numbers":[1,2,5],"value":"B"}]
const outputData = dataManipulator
.Set([{ value: "B", numbers: [2,5,1] }, { numbers: [2,5,1], value: 8 }, { numbers: [2,5,1], value: 5 }])
.DeepSort([{
sortByField: "value",
},
{
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
}
])
.Get();
outputData: [{"value":5,"numbers":[1,2,5]},{"numbers":[1,2,5],"value":8},{"numbers":[1,2,5],"value":"B"}]
const outputData = dataManipulator
.Set({
mike: {
value: [{ val: 5 }, { val: 3 }, { val: 9 }],
data: [6, "4", "ER", 5.43, "5.4"]
},
pike: {
hike: {
bike: {
unsortedArray: [6, 4, 3, 7, 1]
}
},
kick: {}
}
})
.DeepSort([{
fieldName: "mike",
sortDataArray: [{
fieldName: "value",
sortByFunction: (a, b) => {
return b.val - a.val;
}
}, {
fieldName: "data",
sortByField: DM.PrimitiveValue
}]
},
{
fieldName: "pike",
sortDataArray: [{
fieldName: "hike",
sortDataArray: [{
fieldName: "bike",
sortDataArray: [{
fieldName: "unsortedArray",
sortByField: DM.PrimitiveValue
}]
}]
}]
}])
.Get();
outputData: {
mike: {
value: [{ val: 9 }, { val: 5 }, { val: 3 }],
data: ["4", "5.4", 5.43, 6, "ER"]
},
pike: {
hike: {
bike: {
unsortedArray: [1,3,4,6,7]
}
},
kick: {}
}
}
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [2,5,1] },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 }
])
.DeepSort([{
fieldName: 1,
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
},{
sortByField: "value",
}])
.Get();
outputData: [
{"value":5,"numbers":[2,5,1]},
{"numbers":[1,2,5],"value":8},
{"numbers":[2,5,1],"value":"B"}
]
sortByFunction
const outputData = dataManipulator
.Set([5, 2, 7])
.DeepSort({
sortByFunction: (a, b) => b - a,
})
.Get();
outputData: [7, 5, 2]
const outputData = dataManipulator
.Set({
value: [{ val: 5 }, { val: 3 }, { val: 9 }]
})
.DeepSort({
fieldName: "value",
sortByFunction: (a, b) => {
return b.val - a.val;
}
})
.Get();
outputData: {
value: [{ val: 9 }, { val: 5 }, { val: 3 }]
}
sortByReverse
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "5" },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "8" },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "FEWF" },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "5.14" },
{ value: "B", numbers: [2,5,1], anotherValue: "C" },
{ value: "B", numbers: [26, 7, 23], anotherValue: 4, thirdValue: "8" },
])
.DeepSort({
sortByField: ["value", "anotherValue", "thirdValue"],
sortByReverse: true,
sortDataArray: {
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
})
.Get();
outputData: [
{ value: "B", numbers: [1,2,5], anotherValue: "C" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "FEWF" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "8" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "8" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "5.14" },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4, thirdValue: "5" },
{ numbers: [1,2,5], value: 8 },
{ numbers: [1,2,5], value: 5 },
]
fieldPath: Alternative to sortDataArray & fieldName.
const outputData = dataManipulator
.Set([{
values: [{
moreValues: {
a: [5, 2, 7],
b: [5, 2, 7],
c: [5, 2, 7],
d: [5, 2, 7],
e: [5, 2, 7]
}
}],
anotherKEy: "fwefwe"
}])
.DeepSort({
fieldPath: "-.values.-.-.-",
sortByField: DM.PrimitiveValue,
})
.Get();
outputData: [
{
values: [{
moreValues: {
a: [2, 5, 7],
b: [2, 5, 7],
c: [2, 5, 7],
d: [2, 5, 7],
e: [2, 5, 7]
}
}],
anotherKEy: "fwefwe"
}]
const outputData = dataManipulator
.Set([
{
"Apartments": [
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
}
],
},
{
"Apartments": [
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
},
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
},
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
}
]
}
])
.DeepSort({
fieldPath: "[1].Apartments[1].Doors",
sortByField: "doorId",
})
.Get();
outputData:[
{
"Apartments": [
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
}
],
},
{
"Apartments": [
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
},
{
"Doors": [{doorId:1},{doorId:2},{doorId:3},{doorId:5},{doorId:7},{doorId:10}],
},
{
"Doors": [{doorId:5},{doorId:2},{doorId:7},{doorId:3},{doorId:10},{doorId:1}],
}
]
}
]
1.1.0 version updates:
Removed unnessesary required sortByField field when using sortByFunction.
sortByField: "val", // unnessesary
sortByFunction: (a, b) => { //when you make your own sort function
return b.val - a.val;
}
DeepSort(sortDataArray) and sortDataArray inside schema: can now get a single data object instead of array with objects. It's a shortcut for single sortData item.
const outputData = dataManipulator
.Set([
{ value: "B", numbers: [26, 7, 23], anotherValue: 4 },
{ numbers: [2,5,1], value: 8 },
{ numbers: [2,5,1], value: 5 },
{ value: "B", numbers: [2,5,1], anotherValue: "C" },
])
.DeepSort({ //update 1.1.0 -> no need to use array of objects
sortByField: ["value", "anotherValue"],
sortDataArray: { //update 1.1.0 -> no need to use array of objects
fieldName: "numbers",
sortByField: DM.PrimitiveValue
}
})
.Get();
outputData: [
{ numbers: [1,2,5], value: 5 },
{ numbers: [1,2,5], value: 8 },
{ value: "B", numbers: [7, 23, 26], anotherValue: 4 },
{ value: "B", numbers: [1,2,5], anotherValue: "C" },
]
1.2.0 - version update:
using fieldPath with array indexes: still experimental and got bugs! fieldPath: "-.firstArrayName[1].-.secondArrayName[3].-",
Feel free to contact me for suggestions, reporting bugs and etc. dmik86@gmail.com