feat(automapper.module.ts): add profile decorator

Profile decorator deprecates forFeature

BREAKING CHANGE: forFeature has been removed in favor of Profile decorator

#2

Author: Chau Tran

README.md

@@ -69,17 +69,15 @@ Both options are optional. If you pass in `config` and configure your `AutoMappe
 
 2. `AutoMapper` has a concept of `Profile`. A `Profile` is a class that will house some specific mappings related to a specific domain model. Eg: `User` mappings will be housed by `UserProfile`. Refer to [@nartc/automapper: usage](https://github.com/nartc/mapper#usage) for more information regarding `Profile`.
 
-`NestJS` recommends you to separate features/domains in your application into `Modules`, in each module you would import/declare other modules/parts that are related to that Module. `AutomapperModule` also has a static method `forFeature` which should be used in such a feature module. `forFeature` accepts an `AutomapperModuleFeatureOptions` which has:
-- `profiles`: An array of `Profiles` related to this module, and this will be added to an `AutoMapper` instance.
-- `name`: Decide which `AutoMapper` instance to add these profiles to. Default to `"default"`
+`nestjsx-automapper` exposes a `@Profile()` to decorate your `Profile` class.
 
 ```typescript 
-@Module({
-  imports: [AutomapperModule.forFeature({profiles: [new UserProfile()]})]
-})
-export class UserModule {}
+@Profile()
+class UserProfile extends MappingProfileBase {}
 ```
 
+`@Profile(name?: string)` takes in an optional `name` parameter, this is the `name` of the `AutoMapper` instance you want to add this Profile on to.
+
 3. Inject an instance of `AutoMapper` in your `Service`:
 
 ```typescript

src/automapper.explorer.ts

@@ -0,0 +1,41 @@
+import { AutoMapper, MappingProfile } from '@nartc/automapper';
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { MAPPER_MAP } from './utils/mapperMap';
+import { PROFILE_MAP } from './utils/profileMap';
+
+@Injectable()
+export class AutomapperExplorer {
+  constructor(
+    private readonly reflector: Reflector,
+    private readonly logger: Logger,
+    @Inject(MAPPER_MAP) private readonly mapperMap: Map<string, AutoMapper>,
+    @Inject(PROFILE_MAP)
+    private readonly profileMap: Map<
+      string,
+      new (...args: any) => MappingProfile
+    >
+  ) {}
+
+  explore(): void {
+    if (!this.profileMap.size) {
+      return;
+    }
+
+    this.profileMap.forEach(this.exploreProfile.bind(this));
+  }
+
+  private exploreProfile(value: new (...args: any) => MappingProfile) {
+    const mapperKey = this.reflector.get<string>('AUTO_MAPPER_PROFILE', value);
+    const mapper = this.mapperMap.get(mapperKey);
+
+    if (!mapper) {
+      this.logger.error(
+        `There is no Mapper associated with name ${mapperKey.split('__').pop()}`
+      );
+      return;
+    }
+
+    mapper.addProfile(new value());
+  }
+}

src/automapper.module.ts

@@ -1,14 +1,14 @@
 import { AutoMapper } from '@nartc/automapper';
-import { DynamicModule, Global, Logger, Module } from '@nestjs/common';
-import { forFeatureProviders, forRootProviders } from './automapper.provider';
-import {
-  AutomapperModuleFeatureOptions,
-  AutomapperModuleRootOptions,
-} from './interfaces';
+import { DynamicModule, Logger, Module } from '@nestjs/common';
+import { OnModuleInit } from '@nestjs/common/interfaces';
+import { AutomapperExplorer } from './automapper.explorer';
+import { forRootProviders } from './automapper.provider';
+import { AutomapperModuleRootOptions } from './interfaces';
+import { MAPPER_MAP, MapperMap } from './utils/mapperMap';
+import { PROFILE_MAP, ProfileMap } from './utils/profileMap';
 
-@Global()
 @Module({})
-export class AutomapperModule {
+export class AutomapperModule implements OnModuleInit {
   private static readonly logger: Logger = new Logger('AutomapperModule');
 
   /**
@@ -26,29 +26,20 @@ export class AutomapperModule {
 
     return {
       module: AutomapperModule,
-      providers,
+      providers: [
+        ...providers,
+        AutomapperExplorer,
+        { provide: PROFILE_MAP, useValue: ProfileMap },
+        { provide: MAPPER_MAP, useValue: MapperMap },
+        { provide: Logger, useValue: this.logger },
+      ],
       exports: providers,
     };
   }
 
-  /**
-   * Add to the AutoMapper instance a list of MappingProfiles. By default, the instance with name "default" will be
-   * used.
-   *
-   * @param {AutomapperModuleFeatureOptions} options
-   */
-  static forFeature(options: AutomapperModuleFeatureOptions): DynamicModule {
-    if (!options || (options && !options.profiles.length)) {
-      const message = 'AutomapperModuleFeatureOptions.profiles is empty';
-      this.logger.error(message);
-      throw new Error(message);
-    }
-    const providers = forFeatureProviders(options);
-    return {
-      module: AutomapperModule,
-      imports: [AutomapperModule],
-      providers,
-      exports: providers,
-    };
+  constructor(private readonly explorer: AutomapperExplorer) {}
+
+  onModuleInit(): void {
+    this.explorer.explore();
   }
 }

src/automapper.provider.ts

@@ -1,11 +1,8 @@
 import { AutoMapper } from '@nartc/automapper';
 import { Provider } from '@nestjs/common';
-import {
-  AutomapperModuleFeatureOptions,
-  AutomapperModuleRootOptions,
-} from './interfaces';
+import { AutomapperModuleRootOptions } from './interfaces';
 import { getMapperToken } from './utils/getMapperToken';
-import { MAPPER_MAP, MapperMap } from './utils/mapperMap';
+import { MapperMap } from './utils/mapperMap';
 
 export const forRootProviders = (
   mapper: AutoMapper,
@@ -19,28 +16,5 @@ export const forRootProviders = (
       provide: token,
       useValue: mapper,
     },
-    {
-      provide: MAPPER_MAP,
-      useValue: MapperMap,
-    },
-  ];
-};
-
-export const forFeatureProviders = (
-  options: AutomapperModuleFeatureOptions
-): Provider[] => {
-  const token = getMapperToken(options ? options.name : '');
-  const _mapper = MapperMap.has(token)
-    ? (MapperMap.get(token) as AutoMapper)
-    : new AutoMapper();
-
-  options.profiles.forEach(_mapper.addProfile.bind(_mapper));
-  !MapperMap.has(token) && MapperMap.set(token, _mapper);
-
-  return [
-    {
-      provide: token,
-      useValue: _mapper,
-    },
   ];
 };

src/decorators/index.ts

@@ -1 +1,2 @@
 export * from './inject-mapper.decorator';
+export * from './profile.decorator';

src/decorators/profile.decorator.ts

@@ -0,0 +1,10 @@
+import { SetMetadata } from '@nestjs/common/decorators';
+import { getMapperToken } from '../utils/getMapperToken';
+import { ProfileMap } from '../utils/profileMap';
+
+export const Profile: (name?: string) => ClassDecorator = (name?: string) => (
+  target: any
+) => {
+  !ProfileMap.has(target) && ProfileMap.set(target, target);
+  SetMetadata('AUTO_MAPPER_PROFILE', getMapperToken(name))(target);
+};

src/interfaces/automapper-configuration.interface.ts

@@ -1,4 +1,4 @@
-import { AutoMapperConfiguration, MappingProfile } from '@nartc/automapper';
+import { AutoMapperConfiguration } from '@nartc/automapper';
 
 export interface AutomapperModuleRootOptions {
   /**
@@ -15,17 +15,3 @@ export interface AutomapperModuleRootOptions {
    */
   name?: string;
 }
-
-export interface AutomapperModuleFeatureOptions {
-  /**
-   * An array of MappingProfile to be added to the AutoMapper instance
-   */
-  profiles: Array<MappingProfile>;
-
-  /**
-   * Name of the AutoMapper instance
-   *
-   * @default default
-   */
-  name?: string;
-}

src/utils/profileMap.ts

@@ -0,0 +1,7 @@
+import { MappingProfile } from '@nartc/automapper';
+
+export const PROFILE_MAP = 'nestjs__PROFILE_MAP';
+export const ProfileMap: Map<
+  string,
+  new (...args: any) => MappingProfile
+> = new Map<string, { new (...args: any): MappingProfile }>();

test/automapper.test.ts

@@ -2,7 +2,7 @@ import { AutoMapper, MappingProfileBase } from '@nartc/automapper';
 import { Module } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { Expose } from 'class-transformer';
-import { AutomapperModule } from '../src';
+import { AutomapperModule, Profile } from '../src';
 import { getMapperToken } from '../src/utils/getMapperToken';
 import { MAPPER_MAP } from '../src/utils/mapperMap';
 
@@ -16,6 +16,7 @@ class MockVm {
   bar!: string;
 }
 
+@Profile()
 class MockProfile extends MappingProfileBase {
   constructor() {
     super();
@@ -29,82 +30,37 @@ class MockProfile extends MappingProfileBase {
   }
 }
 
-@Module({
-  imports: [AutomapperModule.forRoot()],
-})
-class MockModule {}
+class Another {
+  @Expose()
+  baz!: string;
+}
 
-@Module({
-  imports: [
-    AutomapperModule.forRoot({
-      config: cfg => {
-        cfg.addProfile(new MockProfile());
-      },
-    }),
-  ],
-})
-class MockModuleWithConfig {}
+@Profile()
+class AnotherProfile extends MappingProfileBase {
+  constructor() {
+    super();
+  }
+
+  configure(mapper: AutoMapper): void {
+    mapper.createMap(Another, MockVm);
+  }
+}
 
 @Module({
-  imports: [AutomapperModule.forFeature({ profiles: [new MockProfile()] })],
+  imports: [AutomapperModule.forRoot()],
 })
-class MockSubModule {}
-
-describe('AutomapperModule - with config', () => {
-  let moduleFixture: TestingModule;
-  let mapper: AutoMapper;
-  let mapperMap: Map<string, AutoMapper>;
-
-  beforeAll(async () => {
-    moduleFixture = await Test.createTestingModule({
-      imports: [MockModuleWithConfig],
-    }).compile();
-    mapperMap = moduleFixture.get<Map<string, AutoMapper>>(MAPPER_MAP);
-    mapper = moduleFixture.get<AutoMapper>(getMapperToken());
-  });
-
-  afterAll(() => {
-    mapper.dispose();
-  });
-
-  it('AutomapperModule has been initialized with config', () => {
-    expect(mapperMap.size).toBeGreaterThan(0);
-    expect(mapper).toBeTruthy();
-    expect(JSON.stringify(mapper)).toEqual(
-      JSON.stringify(mapperMap.get(getMapperToken()))
-    );
-  });
-
-  it('AutomapperModule - map with config', () => {
-    const _mock = new Mock();
-    _mock.foo = 'baz';
-
-    const vm = mapper.map(_mock, MockVm);
-    expect(vm).toBeTruthy();
-    expect(vm.bar).toEqual(_mock.foo);
-    expect(vm).toBeInstanceOf(MockVm);
-  });
-
-  it('AutomapperModule - reverseMap with config', () => {
-    const _mockVm = new MockVm();
-    _mockVm.bar = 'should be foo';
-
-    const _mock = mapper.map(_mockVm, Mock);
-    expect(_mock).toBeTruthy();
-    expect(_mock).toBeInstanceOf(Mock);
-    expect(_mock.foo).toEqual(_mockVm.bar);
-  });
-});
+class MockModule {}
 
-describe('AutoMapperModuke', () => {
+describe('AutoMapperModule', () => {
   let moduleFixture: TestingModule;
   let mapper: AutoMapper;
   let mapperMap: Map<string, AutoMapper>;
 
   beforeAll(async () => {
     moduleFixture = await Test.createTestingModule({
-      imports: [MockModule, MockSubModule],
+      imports: [MockModule],
     }).compile();
+    moduleFixture.get(AutomapperModule).onModuleInit();
     mapperMap = moduleFixture.get<Map<string, AutoMapper>>(MAPPER_MAP);
     mapper = moduleFixture.get<AutoMapper>(getMapperToken());
   });

tsconfig.json

@@ -13,9 +13,10 @@
     "strictNullChecks": true,
     "strictFunctionTypes": true,
     "strictPropertyInitialization": true,
+    "downlevelIteration": true,
     "noImplicitThis": true,
     "alwaysStrict": true,
-    "noUnusedLocals": true,
+    "noUnusedLocals": false,
     "noUnusedParameters": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,