Typescript OneOf: Find matching type if OneClass has no discriminator

Author: ksvirkou-hubspot

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptClientCodegen.java

@@ -174,7 +174,8 @@ public TypeScriptClientCodegen() {
         // models
         setModelPackage("models");
         supportingFiles.add(new SupportingFile("model" + File.separator + "ObjectSerializer.mustache", "models", "ObjectSerializer.ts"));
-        supportingFiles.add(new SupportingFile("model" + File.separator + "OneOfInterface.mustache", "models", "OneOfInterface.ts"));
+        supportingFiles.add(new SupportingFile("model" + File.separator + "OneOfClass.mustache", "models", "OneOfClass.ts"));
+
         modelTemplateFiles.put("model" + File.separator + "model.mustache", ".ts");
 
         // api

modules/openapi-generator/src/main/resources/typescript/model/ObjectSerializer.mustache

@@ -128,7 +128,15 @@ export class ObjectSerializer {
             // Check the discriminator
             let discriminatorProperty = typeMap[expectedType].discriminator;
             if (discriminatorProperty == null) {
-                return expectedType; // the type does not have a discriminator. use it.
+                if (this.hasFindMatchingTypeMethod(typeMap[expectedType])) {
+                    const foundType = typeMap[expectedType].findMatchingType(data);
+                    if (foundType == undefined) {
+                        throw new Error("Unable to determine a unique type for the provided object: oneOf type resolution failed. The object does not match exactly one schema. Consider adding a discriminator or making schemas mutually exclusive.");
+                    }
+
+                    return foundType;
+                }
+                return expectedType; // the type does not have a discriminator and findMatchingType method. use it.
             } else {
                 if (data[discriminatorProperty]) {
                     var discriminatorType = data[discriminatorProperty];
@@ -147,6 +155,13 @@ export class ObjectSerializer {
         }
     }
 
+    public static hasFindMatchingTypeMethod(klass: any): boolean {
+        if (typeof klass.findMatchingType === 'function') {
+            return true;
+        }
+        return false;
+    }
+
     public static serialize(data: any, type: string, format: string): any {
         if (data == undefined) {
             return data;

modules/openapi-generator/src/main/resources/typescript/model/OneOfClass.mustache

@@ -0,0 +1,13 @@
+export class OneOfClass {
+    public static instanceOf(data: any, attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string, required: boolean}>): boolean {
+        for(const attribute of attributeTypeMap) {
+            if (attribute.required) {
+                if (!(attribute.baseName in data) || data[attribute.baseName] === undefined) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

modules/openapi-generator/src/main/resources/typescript/model/OneOfInterface.mustache

@@ -6,7 +6,7 @@ import { {{classname}} } from '{{filename}}{{importFileExtension}}';
 {{/tsImports}}
 {{#oneOf}}
     {{#-first}}
-import { OneOfInterface } from '../models/OneOfInterface{{importFileExtension}}'
+import { OneOfClass } from '../models/OneOfClass{{importFileExtension}}';
     {{/-first}}
 {{/oneOf}}
 {{^oneOf}}
@@ -53,13 +53,14 @@ export class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
     {{/hasDiscriminatorWithNonEmptyMapping}}
 
     {{^isArray}}
-    static {{#parent}}override {{/parent}}readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string}> = [
+    static {{#parent}}override {{/parent}}readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string, required: boolean}> = [
         {{#vars}}
         {
             "name": "{{name}}",
             "baseName": "{{baseName}}",
             "type": "{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}",
-            "format": "{{dataFormat}}"
+            "format": "{{dataFormat}}",
+            "required": {{required}}
         }{{^-last}},
         {{/-last}}
         {{/vars}}

modules/openapi-generator/src/main/resources/typescript/model/model.mustache

@@ -10,7 +10,7 @@ export type {{classname}} = {{#oneOf}}{{{.}}}{{^-last}} | {{/-last}}{{/oneOf}};
     * {{{.}}}{{/description}}
 * @export
 */
-export class {{classname}}Class implements OneOfInterface {
+export class {{classname}}Class extends OneOfClass {
     {{#discriminator}}
     static readonly discriminator: string | undefined = "{{discriminatorName}}";
     {{/discriminator}}
@@ -30,7 +30,15 @@ export class {{classname}}Class implements OneOfInterface {
     static readonly mapping: {[index: string]: string} | undefined = undefined;
     {{/hasDiscriminatorWithNonEmptyMapping}}
 
-    findMatchingType(): string | undefined {
+    static readonly arrayOfTypes: Array<{{#oneOf}}typeof {{{.}}}{{^-last}} | {{/-last}}{{/oneOf}}> = [{{#oneOf}}{{{.}}}{{^-last}}, {{/-last}}{{/oneOf}}];
+
+    public static findMatchingType(data:any): string | undefined {
+        for(const type of this.arrayOfTypes) {
+            if (this.instanceOf(data, type.getAttributeTypeMap())) {
+                return type.name;
+            }
+        }
+
         return undefined;
     }
 }