adds discriminator mappings to the ObjectSerializer

This allows (de)serializing models using `oneOf` via the union type
name, returning the proper sub-type. Part of OpenAPITools#10145.

Author: sarumont

modules/openapi-generator/src/main/resources/typescript-node/models.mustache

@@ -62,12 +62,34 @@ let typeMap: {[index: string]: any} = {
     {{#models}}
         {{#model}}
             {{^isEnum}}
+            {{^discriminator}}
     "{{classname}}": {{classname}},
+            {{/discriminator}}
             {{/isEnum}}
         {{/model}}
     {{/models}}
 }
 
+let unionMap: {[index: string]: {discriminator: string, mapping: Record<string, string>}} = {
+    {{#models}}
+        {{#model}}
+            {{^isEnum}}
+            {{#discriminator}}
+                "{{classname}}": {
+                    "discriminator": "{{discriminator.propertyName}}",
+                    "mapping": {
+                    {{#mappedModels}}
+                        "{{mappingName}}": "{{modelName}}",
+                    {{/mappedModels}}
+                    }
+                },
+            {{/discriminator}}
+            {{/isEnum}}
+        {{/model}}
+    {{/models}}
+}
+
+
 export class ObjectSerializer {
     public static findCorrectType(data: any, expectedType: string) {
         if (data == undefined) {
@@ -81,24 +103,36 @@ export class ObjectSerializer {
                 return expectedType;
             }
 
-            if (!typeMap[expectedType]) {
+            if (!typeMap[expectedType] && !unionMap[expectedType]) {
                 return expectedType; // w/e we don't know the type
             }
 
-            // Check the discriminator
-            let discriminatorProperty = typeMap[expectedType].discriminator;
-            if (discriminatorProperty == null) {
-                return expectedType; // the type does not have a discriminator. use it.
+            if (unionMap[expectedType]) {
+                const discriminator = unionMap[expectedType];
+                let discriminatorValue = data[discriminator.discriminator];
+                if (discriminatorValue && discriminator.mapping[discriminatorValue]) {
+                    // found a subclass
+                    return discriminator.mapping[discriminatorValue];
+                } else if (discriminatorValue && typeMap[discriminatorValue]) {
+                    // legacy fallback behavior
+                    return typeMap[discriminatorValue];
+                }
             } else {
-                if (data[discriminatorProperty]) {
-                    var discriminatorType = data[discriminatorProperty];
-                    if(typeMap[discriminatorType]){
-                        return discriminatorType; // use the type given in the discriminator
+                // Check the discriminator
+                let discriminatorProperty = typeMap[expectedType].discriminator;
+                if (discriminatorProperty == null) {
+                    return expectedType; // the type does not have a discriminator. use it.
+                } else {
+                    if (data[discriminatorProperty]) {
+                        var discriminatorType = data[discriminatorProperty];
+                        if(typeMap[discriminatorType]){
+                            return discriminatorType; // use the type given in the discriminator
+                        } else {
+                            return expectedType; // discriminator did not map to a type
+                        }
                     } else {
-                        return expectedType; // discriminator did not map to a type
+                        return expectedType; // discriminator was not present (or an empty string)
                     }
-                } else {
-                    return expectedType; // discriminator was not present (or an empty string)
                 }
             }
         }