feat(core,nestjs,docs): Finalize the async support effort started by #617

packages/core/src/lib/mappings/map-member.ts

@@ -1,24 +1,28 @@
-import type {
+import {
     ConditionReturn,
     ConvertUsingReturn,
     Dictionary,
     FromValueReturn,
     MapDeferReturn,
+    MapFnClassId,
     MapFromReturn,
     Mapper,
     MapWithArgumentsReturn,
     MapWithReturn,
     MemberMapReturn,
     MetadataIdentifier,
     Primitive,
+    SelectorReturn,
+    TransformationType
 } from '../types';
-import { MapFnClassId, TransformationType } from '../types';
 import { isDateConstructor } from '../utils/is-date-constructor';
 import { isPrimitiveConstructor } from '../utils/is-primitive-constructor';
+import { asyncAware } from '../utils/async-aware';
 
 export function mapMember<
     TSource extends Dictionary<TSource>,
-    TDestination extends Dictionary<TDestination>
+    TDestination extends Dictionary<TDestination>,
+    IsAsync extends boolean = false,
 >(
     transformationMapFn: MemberMapReturn<TSource, TDestination>,
     sourceObject: TSource,
@@ -27,7 +31,8 @@ export function mapMember<
     extraArgs: Record<string, any> | undefined,
     mapper: Mapper,
     sourceMemberIdentifier?: MetadataIdentifier | Primitive | Date,
-    destinationMemberIdentifier?: MetadataIdentifier | Primitive | Date
+    destinationMemberIdentifier?: MetadataIdentifier | Primitive | Date,
+    isAsync?: IsAsync,
 ) {
     let value: unknown;
     const transformationType: TransformationType =
@@ -57,7 +62,8 @@ export function mapMember<
             )(
                 sourceObject,
                 mapper,
-                extraArgs ? { extraArgs: () => extraArgs } : undefined
+                extraArgs ? { extraArgs: () => extraArgs } : undefined,
+                isAsync
             );
             break;
         case TransformationType.ConvertUsing:
@@ -66,28 +72,33 @@ export function mapMember<
                     TSource,
                     TDestination
                 >[MapFnClassId.fn]
-            )(sourceObject);
+            )(sourceObject, isAsync as IsAsync);
             break;
         case TransformationType.Condition:
         case TransformationType.NullSubstitution:
         case TransformationType.UndefinedSubstitution:
-            value = (
-                mapFn as ConditionReturn<TSource, TDestination>[MapFnClassId.fn]
-            )(sourceObject, destinationMemberPath);
-
-            if (shouldRunImplicitMap && value != null) {
-                value = Array.isArray(value)
-                    ? mapper.mapArray(
-                          value,
-                          sourceMemberIdentifier as MetadataIdentifier,
-                          destinationMemberIdentifier as MetadataIdentifier
-                      )
-                    : mapper.map(
-                          value,
-                          sourceMemberIdentifier as MetadataIdentifier,
-                          destinationMemberIdentifier as MetadataIdentifier
-                      );
-            }
+            value = asyncAware(
+                () => (
+                    mapFn as ConditionReturn<TSource, TDestination>[MapFnClassId.fn]
+                )(sourceObject, destinationMemberPath, isAsync as boolean),
+                (value) => {
+                    if (shouldRunImplicitMap && value != null) {
+                        return Array.isArray(value)
+                            ? mapper.mapArray(
+                              value,
+                              sourceMemberIdentifier as MetadataIdentifier,
+                              destinationMemberIdentifier as MetadataIdentifier
+                            )
+                            : mapper.map(
+                              value,
+                              sourceMemberIdentifier as MetadataIdentifier,
+                              destinationMemberIdentifier as MetadataIdentifier
+                            );
+                    }
+                    return value;
+                },
+                isAsync
+            );
 
             break;
         case TransformationType.MapWithArguments:
@@ -98,23 +109,29 @@ export function mapMember<
                 >[MapFnClassId.fn]
             )(sourceObject, extraArgs || {});
             break;
-        case TransformationType.MapDefer:
-            value = mapMember(
-                (
-                    mapFn as MapDeferReturn<
-                        TSource,
-                        TDestination
-                    >[MapFnClassId.fn]
-                )(sourceObject) as MemberMapReturn<TSource, TDestination>,
-                sourceObject,
-                destinationObject,
-                destinationMemberPath,
-                extraArgs,
-                mapper,
-                sourceMemberIdentifier,
-                destinationMemberIdentifier
+        case TransformationType.MapDefer: {
+          value = asyncAware(() => (
+            mapFn as MapDeferReturn<
+              TSource,
+              TDestination,
+              SelectorReturn<TDestination>
+            >[MapFnClassId.fn]
+          )(sourceObject), (deferFunction) => {
+            return mapMember(
+              deferFunction,
+              sourceObject,
+              destinationObject,
+              destinationMemberPath,
+              extraArgs,
+              mapper,
+              sourceMemberIdentifier,
+              destinationMemberIdentifier,
+              isAsync
             );
-            break;
+          }, isAsync);
+
+          break;
+        }
     }
     return value;
 }