Need Package Maintenance

    TypeScript icon, indicating that this package has built-in type declarations

    8.7.7 • Public • Published


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


    npm i @automapper/classes

    or with yarn:

    yarn add @automapper/classes


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

    npm i @automapper/core reflect-metadata

    or with yarn:

    yarn add @automapper/core reflect-metadata


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

    import { classes, AutoMap } from '@automapper/classes';
    import { createMapper, createMap, forMember, mapFrom } from '@automapper/core';
    const mapper = createMapper({
      strategyInitializer: classes()
    class User {
        firstName: string;
        lastName: string;
        constructor(firstName: string, lastName: string) {
            this.firstName = firstName;
            this.lastName = lastName;
    class UserDto {
      firstName: string;
      lastName: string;
      fullName: string;
            d => d.fullName,
            mapFrom(s => s.firstName + ' ' + s.lastName)
    ); User('Auto', 'Mapper'), User, UserDto);
    // UserDto { firstName: 'Auto', lastName: 'Mapper', fullName: 'Auto Mapper' }


    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:

      export type DestinationConstructor<
          TSource extends Dictionary<TSource> = any,
          TDestination extends Dictionary<TDestination> = any
      > = (
          sourceObject: TSource, // the sourceObject used to map to the Destination
          destinationIdentifier: MetadataIdentifier<TDestination> // the Destination model
      ) => TDestination;
      // example, User, UserDto);
      // sourceObject will be "user"
      // destinationIdentifier will be "UserDto"
      // 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:

      export type ApplyMetadataFn = <TModel extends Dictionary<TModel>>(
          model: MetadataIdentifier<TModel>
      ) => TModel;
      export type ApplyMetadata = (
          strategy: MappingStrategy<MetadataIdentifier>
      ) => ApplyMetadataFn;
      // for example
      const customApplyMetadata: ApplyMetadata = (strategy: MappingStrategy) => {
          // strategy contains the Mapper which stores all the models' metadata
          return (model) => {
              // based on this model, you can extract the metadata and do as you like
              return anObjectThatHasTheMetadataApplied; // { foo: undefined, bar: undefined }

    Read more about this strategy on classes documentation


    npm i @automapper/classes

    DownloadsWeekly Downloads






    Unpacked Size

    70.6 kB

    Total Files


    Last publish


    • nartc