feat(nestjs): add nestjs integration package

jest.config.js

@@ -4,5 +4,6 @@ module.exports = {
     '<rootDir>/packages/classes',
     '<rootDir>/packages/integration-test',
     '<rootDir>/packages/pojos',
+    '<rootDir>/packages/nestjs',
   ],
 };

nx.json

@@ -42,6 +42,9 @@
     },
     "pojos": {
       "tags": []
+    },
+    "nestjs": {
+      "tags": []
     }
   },
   "workspaceLayout": {

package.json

@@ -54,6 +54,7 @@
   ],
   "dependencies": {},
   "devDependencies": {
+    "@nestjs/common": "7.6.5",
     "@nrwl/cli": "11.0.20",
     "@nrwl/eslint-plugin-nx": "11.0.20",
     "@nrwl/jest": "11.0.20",

packages/classes/src/lib/classes.ts

@@ -1,9 +1,8 @@
 import { createInitialMapping } from '@automapper/core';
 import type {
   Dictionary,
-  ErrorHandler,
   Mapping,
-  MapPlugin,
+  MapPluginInitializer,
 } from '@automapper/types';
 import { MappingClassId } from '@automapper/types';
 import 'reflect-metadata';
@@ -21,9 +20,7 @@ import { instantiate, isClass } from './utils';
  *
  * @param {ErrorHandler} errorHandler
  */
-export const classes = (
-  errorHandler: ErrorHandler
-): MapPlugin<Constructible> => {
+export const classes: MapPluginInitializer<Constructible> = (errorHandler) => {
   // Initialize all the storages
   const metadataStorage = new ClassMetadataStorage();
   const mappingStorage = new ClassMappingStorage();

packages/core/src/lib/create-mapper.ts

@@ -31,7 +31,7 @@ export function createMapper<TKey = unknown>({
   name,
   pluginInitializer,
   namingConventions,
-  errorHandle: customErrorHandler,
+  errorHandler: customErrorHandler,
 }: CreateMapperOptions<TKey>): Mapper<TKey> {
   // default errorHandler to console.error
   const errorHandler = customErrorHandler || { handle: console.error };

packages/integration-test/src/lib/setup.spec.ts

@@ -13,7 +13,7 @@ export function setup(
     name,
     pluginInitializer,
     namingConventions,
-    errorHandle: { handle: spiedErrorHandle },
+    errorHandler: { handle: spiedErrorHandle },
   });
 
   afterEach(() => {

packages/nestjs/.eslintrc.json

@@ -0,0 +1 @@
+{ "extends": "../../.eslintrc.json", "ignorePatterns": ["!**/*"], "rules": {} }

packages/nestjs/README.md

@@ -0,0 +1,7 @@
+# nestjs
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test nestjs` to execute the unit tests via [Jest](https://jestjs.io).

packages/nestjs/jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+  displayName: 'nestjs',
+  preset: '../../jest.preset.js',
+  globals: {
+    'ts-jest': {
+      tsConfig: '<rootDir>/tsconfig.spec.json',
+    },
+  },
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]sx?$': 'ts-jest',
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../coverage/packages/nestjs',
+};

packages/nestjs/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@automapper/nestjs",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@nestjs/common": "^7.0.0",
+    "@nestjs/core": "^7.0.0"
+  }
+}

packages/nestjs/src/index.ts

@@ -0,0 +1,4 @@
+export * from './lib/automapper.module';
+export * from './lib/interfaces';
+export * from './lib/di';
+export * from './lib/abstracts';

packages/nestjs/src/lib/abstracts/automapper-profile.abstract.ts

@@ -0,0 +1,12 @@
+import type { Mapper, MappingProfile } from '@automapper/types';
+
+export abstract class AutomapperProfile {
+  protected mapper: Mapper;
+
+  protected constructor(mapper: Mapper) {
+    this.mapper = mapper;
+    this.mapper.addProfile(this.mapProfile());
+  }
+
+  abstract mapProfile(): MappingProfile;
+}

packages/nestjs/src/lib/abstracts/index.ts

@@ -0,0 +1 @@
+export * from './automapper-profile.abstract';

packages/nestjs/src/lib/automapper.module.ts

@@ -0,0 +1,19 @@
+import { DynamicModule, Global, Logger, Module } from '@nestjs/common';
+import type { AutomapperModuleOptions } from './interfaces';
+import { createAutomapperProviders } from './utils';
+
+@Global()
+@Module({})
+export class AutomapperModule {
+  private static readonly logger = new Logger(AutomapperModule.name);
+
+  static forRoot(forRootOptions: AutomapperModuleOptions): DynamicModule {
+    const providers = createAutomapperProviders(forRootOptions, this.logger);
+
+    return {
+      module: AutomapperModule,
+      providers,
+      exports: providers,
+    };
+  }
+}

packages/nestjs/src/lib/di/get-mapper-token.ts

@@ -0,0 +1,5 @@
+export const DEFAULT_MAPPER_TOKEN = 'automapper:nestjs:default';
+
+export function getMapperToken(name?: string) {
+  return name ? `automapper:nestjs:${name}` : DEFAULT_MAPPER_TOKEN;
+}

packages/nestjs/src/lib/di/index.ts

@@ -0,0 +1 @@
+export * from './get-mapper-token';

packages/nestjs/src/lib/interfaces/automapper-module-options.interface.ts

@@ -0,0 +1,15 @@
+import type {
+  CreateMapperOptions,
+  ErrorHandler,
+  NamingConvention,
+} from '@automapper/types';
+
+export interface AutomapperModuleOptions {
+  options: CreateMapperOptions[];
+  globalErrorHandler?: ErrorHandler;
+  globalNamingConventions?: {
+    source: NamingConvention;
+    destination: NamingConvention;
+  };
+  singular?: boolean;
+}

packages/nestjs/src/lib/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './automapper-module-options.interface';

packages/nestjs/src/lib/utils/create-automapper-providers.util.ts

@@ -0,0 +1,60 @@
+import { createMapper } from '@automapper/core';
+import type { Provider } from '@nestjs/common';
+import { Logger } from '@nestjs/common';
+import { getMapperToken } from '../di';
+import type { AutomapperModuleOptions } from '../interfaces';
+
+export function createAutomapperProviders(
+  forRootOptions: AutomapperModuleOptions,
+  logger: Logger
+): Provider[] {
+  const {
+    options,
+    globalErrorHandler,
+    globalNamingConventions,
+    singular = false,
+  } = forRootOptions;
+
+  if (singular) {
+    if (options.length > 1) {
+      const error =
+        'singular cannot be set to true when you have more than one plugin';
+      logger.error(error);
+      throw new Error(error);
+    }
+
+    const [
+      { name, namingConventions, errorHandler, pluginInitializer },
+    ] = options;
+    const mapper = createMapper({
+      name,
+      pluginInitializer,
+      errorHandler: errorHandler ||
+        globalErrorHandler || { handle: logger.error },
+      namingConventions: namingConventions || globalNamingConventions,
+    });
+
+    return [
+      {
+        provide: getMapperToken(),
+        useValue: mapper,
+      },
+    ];
+  }
+
+  return options.map(
+    ({ name, errorHandler, namingConventions, pluginInitializer }) => {
+      const mapper = createMapper({
+        name,
+        pluginInitializer,
+        errorHandler: errorHandler ||
+          globalErrorHandler || { handle: logger.error },
+        namingConventions: namingConventions || globalNamingConventions,
+      });
+      return {
+        provide: getMapperToken(mapper.name),
+        useValue: mapper,
+      };
+    }
+  );
+}

packages/nestjs/src/lib/utils/index.ts

@@ -0,0 +1 @@
+export * from './create-automapper-providers.util'

packages/nestjs/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

packages/nestjs/tsconfig.lib.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"],
+    "target": "es6"
+  },
+  "exclude": ["**/*.spec.ts"],
+  "include": ["**/*.ts"]
+}

packages/nestjs/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "**/*.spec.js",
+    "**/*.spec.jsx",
+    "**/*.d.ts"
+  ]
+}

packages/types/src/options.ts

@@ -4,7 +4,7 @@ import type {
   Mapping,
   NamingConvention,
 } from './core';
-import type { MapPlugin } from './plugin';
+import type { MapPluginInitializer } from './plugin';
 import type { Dictionary } from './utils';
 
 export interface MapOptions<
@@ -32,6 +32,6 @@ export interface CreateMapperOptions<TKey = unknown> {
     source: NamingConvention;
     destination: NamingConvention;
   };
-  pluginInitializer: (errorHandler: ErrorHandler) => MapPlugin<TKey>;
-  errorHandle?: ErrorHandler;
+  pluginInitializer: MapPluginInitializer<TKey>;
+  errorHandler?: ErrorHandler;
 }

packages/types/src/plugin.ts

@@ -1,7 +1,10 @@
-import type { Mapping } from './core';
+import type { ErrorHandler, Mapping } from './core';
 import type { CreateMapOptions } from './options';
 import type { Dictionary } from './utils';
 
+/**
+ * How a plugin should provide
+ */
 export interface MapPlugin<TKey = unknown> {
   /**
    * Instruction on how a plugin should initialize a mapping for a pair of Source <> Destination
@@ -48,3 +51,10 @@ export interface MapPlugin<TKey = unknown> {
    */
   dispose?(): void;
 }
+
+/**
+ * Plugin initializer
+ */
+export interface MapPluginInitializer<TKey = unknown> {
+  (errorHandler: ErrorHandler): MapPlugin<TKey>;
+}