Object mapper for TypeScript
npm install ts-mapperInspired by MaDEiN83 mapper
``bash`
$ npm install ts-mapper
To create a mapping between two objects, you must call the object method createMap of the TypeMapper class.
It takes two interfaces:
- first interface must be the source interface
- second interface must be the destination interface
So, if we have an object of type ISource and we want a object of type IDestination, we should create a new mapping like that:
`ts
import { TypeMapper } from "ts-mapper";
import { ISource, IDestination } = "../path/of/interfaces.ts";
export class Mapper extends TypeMapper {
constructor() {
super();
this.config();
}
private config(): void {
// put here your mapping configurations
this.createMap
}
}
const mapper = new Mapper();
`
After we create a mapping between interfaces, we can now create all mappings between all wanted properties of our objects (source & destination).
For example, if we want to map the property sourceObject.srcOther to destinationObjet.other, we can define rule like that:
`ts`
mapper.createMap
.map(src => src.srcProperty, dest => dest.destProperty)
.map(src => src.srcOther, dest => dest.other);
- src type is ISourcedest
- type is IDestination
You can chain your rules !
conditions method allows you to check if the previous map will be analysed and mapped to the destination object.
Example:
We want to map the property srcProperty (source object) into destProperty (destination object) only if the property visible of the source object is true.
`ts`
mapper.createMap
.map(src => src.srcProperty, dest => dest.destProperty)
.conditions((s: ISource) => s.visible);
The conditions method takes two arguments:
- the source object
- the destination object
Examples:
`ts
mapper
.createMap
.map(src => src.my_prop, dest => dest.myProp)
.conditions((s: ISource, d: IDestination) => s.visible);
mapper
.createMap
.map(src => src.my_prop, dest => dest.myProp)
.conditions((s: ISource, d: IDestination) => s.visible !== d.visible);
`
Sometime the source properties don't match the destination properties.
Example: sourceObject.age can be a string and destinationObject.age is a number.
To work with, you can cast property by chaining the is method after a map.
`ts
import { TypeMapper, AutoMapperTypes } from "ts-mapper";
mapper
.createMap
.map(p => p.age, p => p.age)
.is(AutoMapperTypes.NUMBER);
`
`ts
mapper
.createMap
.map(p => p.name, p => p.name)
.is(AutoMapperTypes.STRING);
const source: ISource = {
name: "Marluan",
email: "marluan@refactoring.com.do",
password: "my_sup3r_s3cr3t_p455w0rd"
};
const destination: IDestination = { name: null };
mapper.map
console.log(destination);
// {
// name: "Marluan";
// }
``