Different approach with discriminator property like in Jackson (Java).

Janis Köhr · Janis Köhr · commit bdf9423fc1df · 2018-04-12T07:40:54.000+02:00
diff --git a/README.md b/README.md
@@ -269,68 +269,30 @@ let album = plainToClass(Album, albumJson);
 
 ### Providing more than one type option
 
-In case the nested object can be of different types, you can provide an array of
-discriminator functions instead of a single type definition. These functions are then used
-to determine the correct target type for the nested object.
+In case the nested object can be of different types, you can provide an additional options object,
+that specifies a discriminator. The discriminator option must define a `property` that holds the sub
+type name for the object and the possible `subTypes`, the nested object can converted to. A sub type
+has a `value`, that holds the constructor of the Type and the `name`, that can match with the `property`
+of the discriminator.
 
 Lets say we have an album that has a top photo. But this photo can be of certain different types.
-And we are trying to convert album plain object to class object:
-
-```typescript
-import {Type, plainToClass} from "class-transformer";
-
-export abstract class Photo {
-    id: number;
-    filename: string;
-}
-
-export class Landscape extends Photo {
-    panorama: boolean;
-}
-
-export class Portrait extends Photo {
-    person: Person;
-}
-
-export class UnderWater extends Photo {
-    depth: number;
-}
-
-function isLandscape(value: any): Function | false {
-    return value.panorama !== undefined ? Landscape : false;
-}
-
-function isPortrait(value: any): Function | false {
-    return value.person !== undefined ? Portrait : false;
-}
-
-function isUnderWater(value: any): Function | false {
-    return value.depth !== undefined ? UnderWater : false;
-}
-
-export class Album {
-
-    id: number;
-    name: string;
-
-    @Type(() => [ isLandscape, isPortrait, isUnderWater ])
-    topPhoto: Landscape | Portrait | UnderWater;
+And we are trying to convert album plain object to class object. The plain object input has to define
+the additional property `__type`. This property is removed during transformation by default:
 
+**JSON input**:
+```json
+{
+    "id": 1,
+    "name": "foo",
+    "topPhoto": {
+        "id": 9,
+        "filename": "cool_wale.jpg",
+        "depth": 1245,
+        "__type": "underwater"
+    }
 }
-
-let album = plainToClass(Album, albumJson);
-// now album is Album object with Landscape, Portrait and UnderWater objects inside
 ```
 
-### Working with an array that holds more than one nested object type
-
-In case you have to deal with an array that holds different kinds of nested objects,
-the `@Type` decorator can be used, too. Here you just give an array of discriminator functions
-instead of a single type definition, in order to be able to determine which type each object has.
-
-Lets stick to the photo album example from above, but here we got different photo types.
-And we are trying to convert the whole album plain object to its class.
-
 ```typescript
 import {Type, plainToClass} from "class-transformer";
 
@@ -351,33 +313,31 @@ export class UnderWater extends Photo {
     depth: number;
 }
 
-function isLandscape(value: any): Function | false {
-    return value.panorama !== undefined ? Landscape : false;
-}
-
-function isPortrait(value: any): Function | false {
-    return value.person !== undefined ? Portrait : false;
-}
-
-function isUnderWater(value: any): Function | false {
-    return value.depth !== undefined ? UnderWater : false;
-}
-
 export class Album {
 
     id: number;
     name: string;
 
-    @Type(() => [ isLandscape, isPortrait, isUnderWater ])
-    photos: (Landscape | Portrait | UnderWater)[];
+    @Type(() => Photo, {
+        discriminator: {
+            property: "__type",
+            subTypes: [
+                { value: Landscape, name: "landscape" },
+                { value: Portrait, name: "portrait" },
+                { value: UnderWater, name: "underwater" }
+            ]
+        }
+    })
+    topPhoto: Landscape | Portrait | UnderWater;
+
 }
 
 let album = plainToClass(Album, albumJson);
-// now album is Album object with Landscape, Portrait and UnderWater objects inside
+// now album is Album object with a UnderWater object without `__type` property.
 ```
 
-Hint: You can also provide a special discriminator function, which returns a standard type,
-as the last element of the type array such that it gets a type for sure.
+Hint: The same applies for arrays with different sub types. Moreover you can specify `keepDiscriminatorProperty: true`
+in the options to keep the discriminator property also inside your resulting class.
 
 ## Exposing getters and method return values
 
diff --git a/src/TransformOperationExecutor.ts b/src/TransformOperationExecutor.ts
@@ -1,7 +1,7 @@
 import { ClassTransformOptions } from "./ClassTransformOptions";
 import { defaultMetadataStorage } from "./storage";
-import { TypeOptions } from "./metadata/ExposeExcludeOptions";
-import { DiscrimnatorFunction } from "./metadata/TypeMetadata";
+import { TypeHelpOptions, Discriminator, TypeOptions } from "./metadata/ExposeExcludeOptions";
+import { TypeMetadata } from "./metadata/TypeMetadata";
 
 export enum TransformationType {
     PLAIN_TO_CLASS,
@@ -31,7 +31,7 @@ export class TransformOperationExecutor {
 
     transform(source: Object | Object[] | any,
         value: Object | Object[] | any,
-        targetType: Function | DiscrimnatorFunction[],
+        targetType: Function | TypeMetadata,
         arrayType: Function,
         isMap: boolean,
         level: number = 0) {
@@ -42,19 +42,24 @@ export class TransformOperationExecutor {
                 const subSource = source ? source[index] : undefined;
                 if (!this.options.enableCircularCheck || !this.isCircular(subValue, level)) {
                     let realTargetType;
-                    if (Array.isArray(targetType)) {
-                        for (const func of targetType) {
-                            const potentialType = func(subValue);
-                            if (potentialType) {
-                                realTargetType = potentialType;
-                                break;
-                            }
+                    if (typeof targetType !== "function" && targetType && targetType.options && targetType.options.discriminator && targetType.options.discriminator.property && targetType.options.discriminator.subTypes) {
+                        if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {
+                            realTargetType = targetType.options.discriminator.subTypes.find((subType) => subType.name === subValue[(targetType as { options: TypeOptions }).options.discriminator.property]);
+                            const options: TypeHelpOptions = { newObject: newValue, object: subValue, property: undefined };
+                            const newType = targetType.typeFunction(options);
+                            realTargetType === undefined ? realTargetType = newType : realTargetType = realTargetType.value;
+                            if (!targetType.options.keepDiscriminatorProperty) delete subValue[targetType.options.discriminator.property];
+                        }
+                        if (this.transformationType === TransformationType.CLASS_TO_CLASS) {
+                            realTargetType = subValue.constructor;
+                        }
+                        if (this.transformationType === TransformationType.CLASS_TO_PLAIN) {
+                            subValue[targetType.options.discriminator.property] = targetType.options.discriminator.subTypes.find((subType) => subType.value === subValue.constructor).name;
                         }
-                        if (typeof realTargetType !== "function") throw Error("None of the given discriminator functions did return a constructor for a type.");
-                        value = this.transform(subSource, subValue, realTargetType, undefined, subValue instanceof Map, level + 1);
                     } else {
-                        value = this.transform(subSource, subValue, targetType, undefined, subValue instanceof Map, level + 1);
+                        realTargetType = targetType;
                     }
+                    const value = this.transform(subSource, subValue, realTargetType, undefined, subValue instanceof Map, level + 1);
                     if (newValue instanceof Set) {
                         newValue.add(value);
                     } else {
@@ -89,22 +94,10 @@ export class TransformOperationExecutor {
 
         } else if (value instanceof Object) {
 
-            if (Array.isArray(targetType)) {
-                for (const func of targetType) {
-                    const potentialType = func(value);
-                    if (potentialType) {
-                        targetType = potentialType;
-                        break;
-                    }
-                }
-                if (typeof targetType !== "function") throw Error("None of the given discriminator functions did return a constructor for a type.");
-            }
-
             // try to guess the type
             if (!targetType && value.constructor !== Object/* && TransformationType === TransformationType.CLASS_TO_PLAIN*/) targetType = value.constructor;
             if (!targetType && source) targetType = source.constructor;
 
-
             if (this.options.enableCircularCheck) {
                 // add transformed type to prevent circular references
                 this.transformedTypesMap.set(value, { level: level, object: value });
@@ -136,8 +129,9 @@ export class TransformOperationExecutor {
 
                     } else if (this.transformationType === TransformationType.CLASS_TO_PLAIN || this.transformationType === TransformationType.CLASS_TO_CLASS) {
                         const exposeMetadata = defaultMetadataStorage.findExposeMetadata((targetType as Function), key);
-                        if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name)
+                        if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {
                             newValueKey = exposeMetadata.options.name;
+                        }
                     }
                 }
 
@@ -157,10 +151,30 @@ export class TransformOperationExecutor {
                     type = targetType;
 
                 } else if (targetType) {
+
                     const metadata = defaultMetadataStorage.findTypeMetadata((targetType as Function), propertyName);
                     if (metadata) {
-                        const options: TypeOptions = { newObject: newValue, object: value, property: propertyName };
-                        type = metadata.typeFunction(options);
+                        const options: TypeHelpOptions = { newObject: newValue, object: value, property: propertyName };
+                        const newType = metadata.typeFunction(options);
+                        if (metadata.options && metadata.options.discriminator && metadata.options.discriminator.property && metadata.options.discriminator.subTypes) {
+                            if (!(value[valueKey] instanceof Array)) {
+                                if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {
+                                    type = metadata.options.discriminator.subTypes.find((subType) => subType.name === subValue[metadata.options.discriminator.property]);
+                                    type === undefined ? type = newType : type = type.value;
+                                    if (!metadata.options.keepDiscriminatorProperty) delete subValue[metadata.options.discriminator.property];
+                                }
+                                if (this.transformationType === TransformationType.CLASS_TO_CLASS) {
+                                    type = subValue.constructor;
+                                }
+                                if (this.transformationType === TransformationType.CLASS_TO_PLAIN) {
+                                    subValue[metadata.options.discriminator.property] = metadata.options.discriminator.subTypes.find((subType) => subType.value === subValue.constructor).name;
+                                }
+                            } else {
+                                type = metadata;
+                            }
+                        } else {
+                            type = newType;
+                        }
                         isSubValueMap = isSubValueMap || metadata.reflectedType === Map;
                     } else if (this.options.targetMaps) { // try to find a type in target maps
                         this.options.targetMaps
@@ -171,6 +185,7 @@ export class TransformOperationExecutor {
 
                 // if value is an array try to get its custom array type
                 const arrayType = value[valueKey] instanceof Array ? this.getReflectedType((targetType as Function), propertyName) : undefined;
+
                 // const subValueKey = TransformationType === TransformationType.PLAIN_TO_CLASS && newKeyName ? newKeyName : key;
                 const subSource = source ? source[valueKey] : undefined;
 
diff --git a/src/decorators.ts b/src/decorators.ts
@@ -1,8 +1,8 @@
 import {ClassTransformer} from "./ClassTransformer";
 import {defaultMetadataStorage} from "./storage";
-import {TypeMetadata, DiscrimnatorFunction} from "./metadata/TypeMetadata";
+import {TypeMetadata} from "./metadata/TypeMetadata";
 import {ExposeMetadata} from "./metadata/ExposeMetadata";
-import {ExposeOptions, ExcludeOptions, TypeOptions, TransformOptions} from "./metadata/ExposeExcludeOptions";
+import {ExposeOptions, ExcludeOptions, TypeHelpOptions, TransformOptions, Discriminator, TypeOptions} from "./metadata/ExposeExcludeOptions";
 import {ExcludeMetadata} from "./metadata/ExcludeMetadata";
 import {TransformMetadata} from "./metadata/TransformMetadata";
 import {ClassTransformOptions} from "./ClassTransformOptions";
@@ -20,13 +20,12 @@ export function Transform(transformFn: (value: any, obj: any, transformationType
 
 /**
  * Specifies a type of the property.
- * The given TypeFunction can return a constructor or in case of an array of different types
- * an array of discriminator functions can be provided.
+ * The given TypeFunction can return a constructor. A discriminator can be given in the options.
  */
-export function Type(typeFunction?: (type?: TypeOptions) => Function | DiscrimnatorFunction[]) {
+export function Type(typeFunction: (type?: TypeHelpOptions) => Function, options?: TypeOptions) {
     return function(target: any, key: string) {
         const type = (Reflect as any).getMetadata("design:type", target, key);
-        const metadata = new TypeMetadata(target.constructor, key, type, typeFunction);
+        const metadata = new TypeMetadata(target.constructor, key, type, typeFunction, options);
         defaultMetadataStorage.addTypeMetadata(metadata);
     };
 }
diff --git a/src/metadata/ExposeExcludeOptions.ts b/src/metadata/ExposeExcludeOptions.ts
@@ -8,6 +8,14 @@ export interface TransformOptions {
 }
 
 export interface TypeOptions {
+    discriminator?: Discriminator;
+    /**
+     * Is false by default.
+     */
+    keepDiscriminatorProperty?: boolean;
+}
+
+export interface TypeHelpOptions {
     newObject: any;
     object: Object;
     property: string;
@@ -26,3 +34,13 @@ export interface ExcludeOptions {
     toClassOnly?: boolean;
     toPlainOnly?: boolean;
 }
+
+export interface Discriminator {
+    property: string;
+    subTypes: JsonSubType[];
+}
+
+export interface JsonSubType {
+    value: new (...args: any[]) => any;
+    name: string;
+}
diff --git a/src/metadata/TypeMetadata.ts b/src/metadata/TypeMetadata.ts
@@ -1,13 +1,12 @@
-import {TypeOptions} from "./ExposeExcludeOptions";
+import {TypeHelpOptions, Discriminator, TypeOptions} from "./ExposeExcludeOptions";
 
 export class TypeMetadata {
 
     constructor(public target: Function,
                 public propertyName: string,
                 public reflectedType: any,
-                public typeFunction: (options?: TypeOptions) => Function | DiscrimnatorFunction[]) {
+                public typeFunction: (options?: TypeHelpOptions) => Function,
+                public options: TypeOptions) {
     }
 
 }
-
-export type DiscrimnatorFunction = (value: any) => Function | false;
diff --git a/test/functional/custom-transform.spec.ts b/test/functional/custom-transform.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,12 @@`
`1`		`-import {TypeOptions} from "./ExposeExcludeOptions";`
	`1`	`+import {TypeHelpOptions, Discriminator, TypeOptions} from "./ExposeExcludeOptions";`
`2`	`2`
`3`	`3`	`export class TypeMetadata {`
`4`	`4`
`5`	`5`	`constructor(public target: Function,`
`6`	`6`	`public propertyName: string,`
`7`	`7`	`public reflectedType: any,`
`8`		`- public typeFunction: (options?: TypeOptions) => Function \| DiscrimnatorFunction[]) {`
	`8`	`+ public typeFunction: (options?: TypeHelpOptions) => Function,`
	`9`	`+ public options: TypeOptions) {`
`9`	`10`	`}`
`10`	`11`
`11`	`12`	`}`
`12`		`-`
`13`		`-export type DiscrimnatorFunction = (value: any) => Function \| false;`