@cubik_ne_rubik/automapper v0.9.5
TypeScript TypeMapper
Inspired by MaDEiN83 mapper and MarluanEspiritusanto ts-mapper
Installation
$ npm install type-mapper
Usage
Create map
To create a mapping between two objects, you must call the object method createMap
of the TypeMapper class.
It takes two types:
- first type is the source type
- second type is the destination type
So, if we have an object of type AnimalDto
and we want a object of type Animal
, we should create a new mapping like that:
import { TypeMapper } from "type-mapper";
export class AnimalDto {
public id: number = 0;
public lastname: string = '';
public firstname: string = '';
public age: number = 0;
}
export class Animal {
public name: string = '';
public color: string = '';
public age: number = 0;
}
function Main() {
const mapper = new TypeMapper();
mapper.createMap(AnimalDto, Animal);
}
Map fields
After we create a mapping between types all properties of objects will be mapped aotomatically.
For example, keys AnimalDto.age
and AnimalDto.age
will be mapped automatically.
Now we can create all mappings between all wanted properties of our objects (source & destination).
mapper.createMap<ISource, IDestination>();
.forMember('ISourceKey', dest: IDestination => dest.key)
For example, if we want to map the properties AnimalDto.firstname and AnimalDto.lastname
to Animal.name
, we can define rule like that:
mapper.createMap(AnimalDto, Animal);
.forMember('name', p => `${p.firstname} ${p.lastname}`)
You can chain your rules !
Conditionnal mapping
conditions
method allows you to check if the previous forMember
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
.
mapper.createMap<ISource, IDestination>();
.forMember(src => src.srcProperty, dest => dest.destProperty)
.conditions((s: ISource) => s.visible);
The conditions
method takes two arguments:
- the source object
- the destination object
Examples:
mapper
.createMap<ISource, IDestination>()
.forMember(src => src.my_prop, dest => dest.myProp)
.conditions((s: ISource, d: IDestination) => s.visible);
mapper
.createMap<ISource, IDestination>()
.forMember(src => src.my_prop, dest => dest.myProp)
.conditions((s: ISource, d: IDestination) => s.visible !== d.visible);
Fly and Casts
Sometime the source properties don't match the destination properties.
Example: AnimalDto.age
can be a string
and Animal.age
is a number
.
To work with, you can cast property by chaining the is
method after a forMember
.
import { TypeMapper, AutoMapperTypes } from "ts-mapper";
mapper
.createMap<ISource, IDestination>()
.forMember(p => p.age, p => p.age)
.is(AutoMapperTypes.NUMBER);
Execution and Mapping
Mapping to new object:
const human = new AnimalDto();
human.firstname = "Vlad";
human.lastname = "Haidei";
human.age = 18;
const animal = mapper.map(human, Animal);
console.log(animal);
// Animal {
// name: 'Vlad Haidei',
// color: '',
// age: 18
// }
Mapping to existed object:
const human = new AnimalDto();
human.firstname = "Vlad";
human.lastname = "Haidei";
human.age = 21;
const animal = new Animal();
animal.age = 18;
animal.color = 'brown';
const result = mapper.mapTo<AnimalDto, Animal>(human, animal);
console.log(result);
// Animal {
// name: 'Vlad Haidei',
// color: 'brown',
// age: 21
// }
console.log(animal);
// Animal {
// name: 'Vlad Haidei',
// color: 'brown',
// age: 21
// }
console.log(result === animal);
// true
Map collection:
const human = new AnimalDto();
human.firstname = "Vlad";
human.lastname = "Haidei";
human.age = 18;
const dog = new AnimalDto();
dog.firstname = "Bob";
dog.lastname = "Doggy";
dog.age = 3;
const animals = mapper.mapCollection([human, dog], Animal);
console.log('animals', animals);
// [Animal {
// name: 'Vlad Haidei',
// color: '',
// age: 18
// },
// Animal {
// name: 'Bob Doggy',
// color: '',
// age: 3
// }]
5 years ago