fix(core): send extraArgs from original map operation to mapWith oper…

…ations ISSUES CLOSED: #509
nartc · Oct 24, 2022 · 65c6a74 · 65c6a74
1 parent d0205a5
commit 65c6a74
Show file tree

Hide file tree

Showing 4 changed files with 98 additions and 40 deletions.
diff --git a/packages/core/src/lib/mappings/map-member.ts b/packages/core/src/lib/mappings/map-member.ts
@@ -54,7 +54,11 @@ export function mapMember<
         case TransformationType.MapWith:
             value = (
                 mapFn as MapWithReturn<TSource, TDestination>[MapFnClassId.fn]
-            )(sourceObject, mapper);
+            )(
+                sourceObject,
+                mapper,
+                extraArgs ? { extraArgs: () => extraArgs } : undefined
+            );
             break;
         case TransformationType.ConvertUsing:
             value = (

diff --git a/packages/core/src/lib/member-map-functions/map-with.ts b/packages/core/src/lib/member-map-functions/map-with.ts
@@ -1,5 +1,6 @@
 import type {
     Dictionary,
+    MapOptions,
     MapWithReturn,
     ModelIdentifier,
     SelectorReturn,
@@ -26,21 +27,23 @@ export function mapWith<
 ): MapWithReturn<TSource, TDestination, TSelectorReturn> {
     return [
         TransformationType.MapWith,
-        (source, mapper) => {
+        (source, mapper, options) => {
             const sourceValue = withSourceValue(source);
 
             if (Array.isArray(sourceValue)) {
                 return mapper.mapArray(
                     sourceValue,
                     withSource,
-                    withDestination
+                    withDestination,
+                    options as unknown as MapOptions<TSource[], TDestination[]>
                 ) as unknown as TSelectorReturn;
             }
 
             return mapper.map(
                 sourceValue,
                 withSource,
-                withDestination
+                withDestination,
+                options
             ) as unknown as TSelectorReturn;
         },
     ];

diff --git a/packages/core/src/lib/types.ts b/packages/core/src/lib/types.ts
@@ -372,7 +372,11 @@ export type MapWithReturn<
     TSelectorReturn = SelectorReturn<TDestination>
 > = [
     TransformationType.MapWith,
-    (sourceObj: TSource, mapper: Mapper) => TSelectorReturn | undefined | null
+    (
+        sourceObj: TSource,
+        mapper: Mapper,
+        options?: MapOptions<TSource, TDestination>
+    ) => TSelectorReturn | undefined | null
 ];
 
 export interface ConditionPredicate<TSource extends Dictionary<TSource>> {

diff --git a/packages/integration-test/src/classes/map-extra-args.spec.ts b/packages/integration-test/src/classes/map-extra-args.spec.ts
@@ -4,49 +4,50 @@ import {
     createMap,
     createMapper,
     forMember,
+    mapWith,
     mapWithArguments,
     Resolver,
 } from '@automapper/core';
 
-describe('Map - Extra Arguments', () => {
-    class Bar {
-        @AutoMap(() => String)
-        bar!: string | null;
-
-        constructor(bar: string) {
-            this.bar = bar;
-        }
-    }
+class Bar {
+    @AutoMap(() => String)
+    bar!: string | null;
 
-    class Foo {
-        @AutoMap()
-        foo!: string;
-        @AutoMap(() => Bar)
-        bar!: Bar;
-        @AutoMap(() => Number)
-        fooBar!: number | null;
-
-        constructor(fooBar: number) {
-            this.foo = `foo${fooBar}`;
-            this.fooBar = fooBar;
-            this.bar = new Bar(`bar${fooBar}`);
-        }
+    constructor(bar: string) {
+        this.bar = bar;
     }
-
-    class BarDto {
-        @AutoMap(() => String)
-        bar!: string | null;
-    }
-
-    class FooDto {
-        @AutoMap()
-        foo!: string;
-        @AutoMap(() => BarDto)
-        bar!: BarDto;
-        @AutoMap(() => Number)
-        fooBar!: number | null;
+}
+
+class Foo {
+    @AutoMap()
+    foo!: string;
+    @AutoMap(() => Bar)
+    bar!: Bar;
+    @AutoMap(() => Number)
+    fooBar!: number | null;
+
+    constructor(fooBar: number) {
+        this.foo = `foo${fooBar}`;
+        this.fooBar = fooBar;
+        this.bar = new Bar(`bar${fooBar}`);
     }
+}
+
+class BarDto {
+    @AutoMap(() => String)
+    bar!: string | null;
+}
+
+class FooDto {
+    @AutoMap()
+    foo!: string;
+    @AutoMap(() => BarDto)
+    bar!: BarDto;
+    @AutoMap(() => Number)
+    fooBar!: number | null;
+}
 
+describe('Map - Extra Arguments', () => {
     const mapper = createMapper({
         strategyInitializer: classes(),
         namingConventions: new CamelCaseNamingConvention(),
@@ -121,3 +122,49 @@ describe('Map - Extra Arguments', () => {
         expect(dto.bar.bar).toEqual(foo.bar.bar + ' concat me');
     });
 });
+
+describe('Map - Extra Arguments deep', () => {
+    const mapper = createMapper({
+        strategyInitializer: classes(),
+        namingConventions: new CamelCaseNamingConvention(),
+    });
+
+    beforeEach(() => {
+        createMap(
+            mapper,
+            Bar,
+            BarDto,
+            forMember(
+                (d) => d.bar,
+                mapWithArguments(
+                    (source, { concat = 'default concat' }) =>
+                        source.bar + ' ' + concat
+                )
+            )
+        );
+
+        createMap(
+            mapper,
+            Foo,
+            FooDto,
+            forMember(
+                (d) => d.bar,
+                mapWith(BarDto, Bar, (s) => s.bar)
+            )
+        );
+    });
+
+    afterEach(() => {
+        mapper.dispose();
+    });
+
+    it('should transfer extra args to nested map', () => {
+        const foo = new Foo(2);
+        const dto = mapper.map(foo, Foo, FooDto, {
+            extraArgs: () => ({ multiplier: 3, concat: 'concat me' }),
+        });
+
+        expect(dto.foo).toEqual(foo.foo);
+        expect(dto.bar.bar).toEqual(foo.bar.bar + ' concat me');
+    });
+});