@jersmart/automapper-classes

This is the official strategy from @automapper to work with TS/ES6 Class

Installation

1npm i @jersmart/automapper-classes

or with yarn:

1yarn add @jersmart/automapper-classes

peerDependencies

@jersmart/automapper-classes depends on @jersmart/automapper-core and reflect-metadata.

1npm i @jersmart/automapper-core reflect-metadata

or with yarn:

1yarn add @jersmart/automapper-core reflect-metadata

Usage

@jersmart/automapper-classes provides classes as a MappingStrategyInitializer. Pass classes() to createMapper to create a Mapper that uses classes strategy.

1import { classes, AutoMap } from '@jersmart/automapper-classes';
2import { createMapper, createMap, forMember, mapFrom } from '@jersmart/automapper-core';
3
4const mapper = createMapper({
5  ...,
6  strategyInitializer: classes()
7});
8
9class User {
10    @AutoMap()
11    firstName: string;
12    @AutoMap()
13    lastName: string;
14
15    constructor(firstName: string, lastName: string) {
16        this.firstName = firstName;
17        this.lastName = lastName;
18    }
19}
20
21class UserDto {
22  @AutoMap()
23  firstName: string;
24  @AutoMap()
25  lastName: string;
26  @AutoMap()
27  fullName: string;
28}
29
30createMap(
31    mapper,
32    User,
33    UserDto,
34    forMember(
35        d => d.fullName,
36        mapFrom(s => s.firstName + ' ' + s.lastName)
37    )
38);
39mapper.map(new User('Auto', 'Mapper'), User, UserDto);
40// UserDto { firstName: 'Auto', lastName: 'Mapper', fullName: 'Auto Mapper' }

Customization

classes() accepts two optional parameters:

• destinationConstructor: how to construct the Destination. This is the default destinationConstructor that will be used on mapper.mapXXXX() operations. DestinationConstructor is a function with the following signature:

  1export type DestinationConstructor<
  2    TSource extends Dictionary<TSource> = any,
  3    TDestination extends Dictionary<TDestination> = any
  4> = (
  5    sourceObject: TSource, // the sourceObject used to map to the Destination
  6    destinationIdentifier: MetadataIdentifier<TDestination> // the Destination model
  7) => TDestination;
  8
  9// example
  10mapper.map(user, User, UserDto);
  11// sourceObject will be "user"
  12// destinationIdentifier will be "UserDto"
  13// This allows you to provide a default constructor that can be based on the Source object data

  • There is a way to provide one-off custom destinationConstructor to any given Mapping when you run createMap. Read more about constructUsing

• applyMetadata: how the strategy should apply the metadata to a model. The default should work for most cases but if you would like to customize this, you can. ApplyMetadata is a function with the following signature:

  1export type ApplyMetadataFn = <TModel extends Dictionary<TModel>>(
  2    model: MetadataIdentifier<TModel>
  3) => TModel;
  4
  5export type ApplyMetadata = (
  6    strategy: MappingStrategy<MetadataIdentifier>
  7) => ApplyMetadataFn;
  8
  9// for example
  10const customApplyMetadata: ApplyMetadata = (strategy: MappingStrategy) => {
  11    // strategy contains the Mapper which stores all the models' metadata
  12    return (model) => {
  13        // based on this model, you can extract the metadata and do as you like
  14
  15        return anObjectThatHasTheMetadataApplied; // { foo: undefined, bar: undefined }
  16    };
  17};

Read more about this strategy on classes documentation