Added sort() and reverseSort() pipeline transformations.
Fixed a bug where {"alwaysSet":true} was not setting an empty array in all use cases.
Upgraded dependencies and changed the build to only support node 8 and higher.
npm audit fixes.
fixed a bug with pipeline transformations.
Fixed a bug when traversing an array of a non-existing object.
The notFound transform function for the to() method will now supply the the type of non-value they discovered (null or undefined).
Fixed a bug where the set method could not be used after the map method.
Fixed a bug with the keep method.
const source = {
"foo": {
"foo1": "bar",
"bar": "bar"
}
}
mapper.map("foo").keep(["foo1", "foo2"]);
// foo2 should not exist here
{
"foo": {
"foo1": "bar",
"foo2": undefined
}
}The to() method now takes a optional notFound transform that allows for basic conditional logic to be applied. For convenience, you can also supply a basic value.
const mapper = createMapper();
// These two mappings are logically equivalent
mapper
.map("amount").to("data", amount => `£${amount}`, () => "£0");
.map("amount").to("data", amount => `£${amount}`, "£0");The source field for the map() method is now optional. If omitted, the method will get the entire source object. This is quite useful when combined with pipeline transformations.
const mapper = createMapper();
mapper
.map().to("data");
.execute({"a": "b"})
/*
{
data: {"a": "b"}
}
*/Added the keep() pipeline transformation.
More details can found in the Pipeline Transformations section of the README.
Added compact(), first(), and last() Pipeline Transformations for more detailed control over arrays.
More details can found in the Pipeline Transformations section of the README.
Mapping can now be conditionally based on other values in the source document using acceptIf() and rejectIf().
More details can found in the Pipeline Transformations section of the README.
New set() feature to allow you to set a value on the target object without requiring a source field.
mapper
.set("my.target.mappingStatus", "mapped");
// OR
mapper
.set("my.target.id", () => createId());Fixes a bug when dealing with arrays of arrays with mapping fields involved in parent-child relationships. This is a breaking change as the values supplied to transforms must preserve a nested array structure to be properly set on the target object. The 2.x versions did not preserve this structure.
The getValue function will also preserve this structure too.
const createMapper = require("map-factory");
let mapper = createMapper();
let src = {
one: [
{ name: "first", two: [{ three: { value1: "A1", value2: "A2" } }, { three: { value1: "B1", value2: "B2" } }] },
{ name: "second", two: [{ three: { value1: "C1", value2: "C2" } }, { three: { value1: "D1", value2: "D2" } }] }
]
};
mapper
.map("one[].name").to("combined[].name")
.map("one[].two[].three[].value1").to("combined[].values[]", value => {
// A transform in v2 received ["A1","B1","C1","D1"]
// The transform in v3 will now receive [["A1","B1"],["C1","D1"]]
return value;
});
let actual = mapper.execute(src);
// The broken result in v2 {"combined":[{"name":"first","values":[["A1","B1","C1","D1"]]},{"name":"second"}]}
// The correct result in v3 {"combined":[{"name":"first","values":["A1","B1"]},{"name":"second","values":["C1","D1"]}]}Additionally the with() modifier has been added that will allow more fine grain control when working with arrays of arrays. More details can be found in the README.
Fixed bug where each() returned a null when supplied with an empty array instead of returing an empty array.
Added the removing() method that allows you to specify which fields you don't want instead of explicitly stating the fields you do want.
const mapper = createMapper();
const src = {
user: {
name: "Tim",
occupation: "Enchanter",
password: "scary bunny"
}
};
mapper
.map("user").removing("password").to("user");
.execute(src);
/*
The expected result is:
{
user: {
name: "Tim",
occupation: "Enchanter"
}
}
*/Fixed a bug where an array of undefined values was calling the transform and set when it shouldn't have.
Added chain method to the mapper which allows you to chain multiple mappers together and execute sequentially.
const source = {
"foo": "bar",
"bar": "foo"
};
const mapper = createMapper();
const secondaryMapper = createMapper();
mapper.map("foo");
secondaryMapper.map("foo").to("bar");
const result = mapper.chain(secondaryMapper).execute(source);
/**
The expected result will be
{
"bar": "bar"
}
**/Added executeAsync() to the mapper which will return a Promise.
Corrected TypeScript definitions.
Put some dev dependencies back where they belong.
Exposes the main two underlying functions: getValue and setValue.
See README for more details.
Removed some debugging code that was accidentally left in.
Made the babel output ES5 to allow use in the browser.
Screwed up with publishing 2.0.0. This fixed that.
In v1 the default behaviour was the equivalent of setting the options as {alwaysTransform: true, alwaysSet: true}. In v2 the default behaviour is now the equivalent of setting the options as {alwaysTransform: false, alwaysSet: false}.
We feel these are generally better defaults. This is a breaking change.
If you prefer the v1 behaviour you just need to change your code as follows:
const mapper = createMapper();const options = {
alwaysTransform: true,
alwaysSet: true
};
const mapper = createMapper(options);Additionally, the v1 behaviour would consider a null an acceptable value if a ? was appended to the to() field. In v2 this behaviour will only work in combination with the always flag.
map("foo.bar").to("bar.bar?");map("foo.bar").always.to("bar.bar?");Bug-fix to make or mode respect behaviour modifiers.
Bug-fix for always and existing modifiers.
Introduced behaviour modifiers to make map-factory more flexible. See README for more details.
const createMapper = require("map-factory");
const options = {
alwaysTransform: false,
alwaysSet: false
};
const mapper = createMapper(options);const createMapper = require("map-factory");
const mapper = createMapper(options);
mapper
.map("a").always.to("b")
.map("c").existing.to("d");Set experimental flag to eliminate some of the object-mapper code
Remove object-mapper dependency
Fixed regression in experimental mode
Added experimental mode to begin absorbing object-mapper into code base
const mapper = createMapper({ experimental:true });Converted code from TypeScript to ES6 with babel
Fixed bug where you couldn't map from the same source field more than once.
Added the chainable or() method to select from alterate source fields.
const mapper = createMapper();
mapper
.map("occupier").or("tenant").or("leasee").to("occupier");Added the each() method to help when working with multiple mappers and arrays.
Actually fixed the links in the docs
Tried and failed to fix links in docs
Improved documentation
Add map method which will improve readability in some use cases Added support for fluent coding style
Added feature to map.execute which allows you to provide an existing object as the target object.
Previous version did not publish properly.
Semver MAJOR: moved source to map.execute();
const createMapper = require("map-factory");
const source = {
"fieldName": "name1",
"fieldId": "123",
"fieldDescription": "description"
};
// Prevents you from reusing the mapper
const map = createMapper(source);
map("fieldName").to("field.name");
map("fieldId").to("field.id");
const result = map.execute();
console.log(result);const createMapper = require("map-factory");
const source = {
"fieldName": "name1",
"fieldId": "123",
"fieldDescription": "description"
};
const map = createMapper();
map("fieldName").to("field.name");
map("fieldId").to("field.id");
// mapper can now be reused
const result = map.execute(source);
console.log(result);