Improve type safety and error reporting for oneOf schema resolution

Author: ksvirkou-hubspot

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

@@ -176,6 +176,7 @@ public TypeScriptClientCodegen() {
         setModelPackage("models");
         supportingFiles.add(new SupportingFile("model" + File.separator + "ObjectSerializer.mustache", "models", "ObjectSerializer.ts"));
         supportingFiles.add(new SupportingFile("model" + File.separator + "TypeMatcher.mustache", "models", "TypeMatcher.ts"));
+        supportingFiles.add(new SupportingFile("model" + File.separator + "ModelTypes.mustache", "models", "ModelTypes.ts"));
 
         modelTemplateFiles.put("model" + File.separator + "model.mustache", ".ts");
 
@@ -1193,7 +1194,6 @@ public ExtendedCodegenModel(CodegenModel cm) {
             this.xmlName = cm.xmlName;
             this.classFilename = cm.classFilename;
             this.unescapedDescription = cm.unescapedDescription;
-            this.discriminator = cm.discriminator;
             this.defaultValue = cm.defaultValue;
             this.arrayModelType = cm.arrayModelType;
             this.isAlias = cm.isAlias;
@@ -1256,6 +1256,7 @@ public ExtendedCodegenModel(CodegenModel cm) {
             this.setAdditionalProperties(cm.getAdditionalProperties());
             this.setIsModel(cm.getIsModel());
             this.setComposedSchemas(cm.getComposedSchemas());
+            this.setDiscriminator(cm.getDiscriminator());
         }
 
     }

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

@@ -0,0 +1,11 @@
+/**
+ * Represents a single attribute/property metadata entry in the attributeTypeMap.
+ * Used for validation and type matching in oneOf scenarios.
+ */
+export type AttributeTypeMapEntry = {
+    name: string;
+    baseName: string;
+    type: string;
+    format: string;
+    required: boolean;
+};

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

@@ -127,7 +127,7 @@ export class ObjectSerializer {
 
             // Check the discriminator
             let discriminatorProperty = typeMap[expectedType].discriminator;
-            if (discriminatorProperty == null) {
+            if (discriminatorProperty == null || !data[discriminatorProperty]) {
                 if (this.hasFindMatchingTypeMethod(typeMap[expectedType])) {
                     const foundType = typeMap[expectedType].findMatchingType(data);
                     if (foundType == undefined) {
@@ -138,18 +138,14 @@ export class ObjectSerializer {
                 }
                 return expectedType; // the type does not have a discriminator and findMatchingType method. use it.
             } else {
-                if (data[discriminatorProperty]) {
-                    var discriminatorType = data[discriminatorProperty];
-                    let mapping = typeMap[expectedType].mapping;
-                    if (mapping != undefined && mapping[discriminatorType]) {
-                        return mapping[discriminatorType]; // use the type given in the discriminator
-                    } else if(typeMap[discriminatorType]) {
-                        return discriminatorType;
-                    } else {
-                        return expectedType; // discriminator did not map to a type
-                    }
+                let discriminatorType = data[discriminatorProperty];
+                let mapping = typeMap[expectedType].mapping;
+                if (mapping != undefined && mapping[discriminatorType]) {
+                    return mapping[discriminatorType]; // use the type given in the discriminator
+                } else if(typeMap[discriminatorType]) {
+                    return discriminatorType;
                 } else {
-                    return expectedType; // discriminator was not present (or an empty string)
+                    throw new Error(`Discriminator property '${discriminatorProperty}' has value '${discriminatorType}' which does not map to any known type in '${expectedType}'.`);
                 }
             }
         }

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

@@ -1,11 +1,13 @@
+import { AttributeTypeMapEntry } from '../models/ModelTypes{{importFileExtension}}';
+
 /**
  * Validates if data contains all required attributes from the attributeTypeMap.
  *
  * @param data - The data object to validate
  * @param attributeTypeMap - Array of attribute metadata including required flag
  * @returns true if all required attributes are present in data, false otherwise
  */
-export function instanceOfType(data: any, attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string, required: boolean}>): boolean {
+export function instanceOfType(data: any, attributeTypeMap: Array<AttributeTypeMapEntry>): boolean {
     for (const attribute of attributeTypeMap) {
         if (attribute.required) {
             // Check both that the property exists AND that it's not undefined.

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

@@ -10,6 +10,7 @@ import { findMatchingType } from '../models/TypeMatcher{{importFileExtension}}';
     {{/-first}}
 {{/oneOf}}
 {{^oneOf}}
+import { AttributeTypeMapEntry } from '../models/ModelTypes{{importFileExtension}}';
 import { HttpFile } from '../http/http{{importFileExtension}}';
 {{/oneOf}}
 
@@ -53,7 +54,7 @@ export class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
     {{/hasDiscriminatorWithNonEmptyMapping}}
 
     {{^isArray}}
-    static {{#parent}}override {{/parent}}readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string, required: boolean}> = [
+    static {{#parent}}override {{/parent}}readonly attributeTypeMap: Array<AttributeTypeMapEntry> = [
         {{#vars}}
         {
             "name": "{{name}}",

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

@@ -2,4 +2,6 @@
 {{#model}}
 export * from '{{{ importPath }}}{{importFileExtension}}'
 {{/model}}
-{{/models}}
+{{/models}}
+export * from './TypeMatcher{{importFileExtension}}'
+export * from './ModelTypes{{importFileExtension}}'