Rewrite OneOfClass to standalone helper TypeMatcher

Author: ksvirkou-hubspot

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

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

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

@@ -0,0 +1,41 @@
+/**
+ * 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 {
+    for (const attribute of attributeTypeMap) {
+        if (attribute.required) {
+            // Check both that the property exists AND that it's not undefined.
+            // This is important because `data[attribute.baseName] === undefined` alone
+            // would be true for both missing properties and properties explicitly set to undefined,
+            // while `!(attribute.baseName in data)` distinguishes between these cases.
+            // For proper OpenAPI validation, required fields must actually be present in the data.
+            if (!(attribute.baseName in data) || data[attribute.baseName] === undefined) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Attempts to find a matching type from an array of possible types by validating
+ * the data against each type's attribute requirements.
+ *
+ * @param data - The data object to match
+ * @param types - Array of possible type constructors
+ * @returns The name of the matching type, or undefined if no match found
+ */
+export function findMatchingType(data: any, types: Array<any>): string | undefined {
+    for (const type of types) {
+        if (instanceOfType(data, type.getAttributeTypeMap())) {
+            return type.name;
+        }
+    }
+
+    return undefined;
+}

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

@@ -6,7 +6,7 @@ import { {{classname}} } from '{{filename}}{{importFileExtension}}';
 {{/tsImports}}
 {{#oneOf}}
     {{#-first}}
-import { OneOfClass } from '../models/OneOfClass{{importFileExtension}}';
+import { findMatchingType } from '../models/TypeMatcher{{importFileExtension}}';
     {{/-first}}
 {{/oneOf}}
 {{^oneOf}}

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 extends OneOfClass {
+export class {{classname}}Class {
     {{#discriminator}}
     static readonly discriminator: string | undefined = "{{discriminatorName}}";
     {{/discriminator}}
@@ -32,13 +32,13 @@ export class {{classname}}Class extends OneOfClass {
 
     private static readonly arrayOfTypes: Array<{{#oneOf}}typeof {{{.}}}{{^-last}} | {{/-last}}{{/oneOf}}> = [{{#oneOf}}{{{.}}}{{^-last}}, {{/-last}}{{/oneOf}}];
 
+    /**
+     * Determines which oneOf schema matches the provided data.
+     *
+     * @param data - The data object to match against oneOf schemas
+     * @returns The name of the matching type, or undefined if no unique match is found
+     */
     public static findMatchingType(data: any): string | undefined {
-        for (const type of this.arrayOfTypes) {
-            if (this.instanceOf(data, type.getAttributeTypeMap())) {
-                return type.name;
-            }
-        }
-
-        return undefined;
+        return findMatchingType(data, this.arrayOfTypes);
     }
 }