Implementation

Author: Geoffroy Empain

src/TransformOperationExecutor.ts

@@ -1,7 +1,6 @@
 import {ClassTransformOptions} from "./ClassTransformOptions";
 import {defaultMetadataStorage} from "./storage";
 import {TypeOptions} from "./metadata/ExposeExcludeOptions";
-import {ExposeMetadata} from "./metadata/ExposeMetadata";
 
 export type TransformationType = "plainToClass"|"classToPlain"|"classToClass";
 
@@ -162,15 +161,15 @@ export class TransformOperationExecutor {
                 if (!this.options.enableCircularCheck || !this.isCircular(subValue, level)) {
                     let transformKey = this.transformationType === "plainToClass" ? newValueKey : key;
                     let finalValue = this.transform(subSource, subValue, type, arrayType, isSubValueMap, level + 1);
-                    finalValue = this.applyCustomTransformations(finalValue, targetType, transformKey);
+                    finalValue = this.applyCustomTransformations(finalValue, targetType, transformKey, value);
                     if (newValue instanceof Map) {
                         newValue.set(newValueKey, finalValue);
                     } else {
                         newValue[newValueKey] = finalValue;
                     }
                 } else if (this.transformationType === "classToClass") {
                     let finalValue = subValue;
-                    finalValue = this.applyCustomTransformations(finalValue, targetType, key);
+                    finalValue = this.applyCustomTransformations(finalValue, targetType, key, value);
                     if (newValue instanceof Map) {
                         newValue.set(newValueKey, finalValue);
                     } else {
@@ -186,7 +185,7 @@ export class TransformOperationExecutor {
         }
     }
 
-    private applyCustomTransformations(value: any, target: Function, key: string) {
+    private applyCustomTransformations(value: any, target: Function, key: string, obj: any) {
         let metadatas = defaultMetadataStorage.findTransformMetadatas(target, key, this.transformationType);
 
         // apply versioning options
@@ -216,7 +215,7 @@ export class TransformOperationExecutor {
         }
 
         metadatas.forEach(metadata => {
-            value = metadata.transformFn(value);
+            value = metadata.transformFn(value, obj);
         });
 
         return value;

src/decorators.ts

@@ -10,7 +10,7 @@ import {ClassTransformOptions} from "./ClassTransformOptions";
 /**
  * Defines a custom logic for value transformation.
  */
-export function Transform(transformFn: (value: any) => any, options?: TransformOptions) {
+export function Transform(transformFn: (value: any, obj: any) => any, options?: TransformOptions) {
     return function(target: any, key: string) {
         const metadata = new TransformMetadata(target.constructor, key, transformFn, options);
         defaultMetadataStorage.addTransformMetadata(metadata);

src/metadata/TransformMetadata.ts

@@ -4,8 +4,8 @@ export class TransformMetadata {
 
     constructor(public target: Function,
                 public propertyName: string,
-                public transformFn: (value: any) => any,
+                public transformFn: (value: any, obj: any) => any,
                 public options: TransformOptions) {
     }
 
-}
+}

test/functional/custom-transform.spec.ts

@@ -123,5 +123,36 @@ describe("custom transformation decorator", () => {
         classedUser5.lastVisitDate.should.be.equal(new Date(plainUser.lastVisitDate).toString());
     });
 
+    it("@Transform decorator callback should be given the source object as second argument", () => {
+        defaultMetadataStorage.clear();
+
+        let objArgToClass: any;
+        let objArgToPlain: any;
+
+        class User {
+            @Transform((value, obj) => {
+                objArgToPlain = obj;
+                return value;
+            }, {toPlainOnly: true})
+            @Transform((value, obj) => {
+                objArgToClass = obj;
+                return value;
+            }, {toClassOnly: true})
+            name: string;
+        }
+
+        let plainUser = {
+            name: "Johny Cage",
+        };
+
+        const user = new User();
+        user.name = "Johny Cage";
+
+        plainToClass(User, plainUser);
+        classToPlain(user);
+
+        objArgToPlain.should.be.equal(user);
+        objArgToClass.should.be.equal(plainUser);
+    });
 
-});
+});