[TypeScript] Implement oneOf type resolution without discriminator

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

@@ -174,6 +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 + "TypeMatcher.mustache", "models", "TypeMatcher.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 {
         }
     }
 
+    private 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/TypeMatcher.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/model.mustache

@@ -4,7 +4,14 @@
 {{#tsImports}}
 import { {{classname}} } from '{{filename}}{{importFileExtension}}';
 {{/tsImports}}
+{{#oneOf}}
+    {{#-first}}
+import { findMatchingType } from '../models/TypeMatcher{{importFileExtension}}';
+    {{/-first}}
+{{/oneOf}}
+{{^oneOf}}
 import { HttpFile } from '../http/http{{importFileExtension}}';
+{{/oneOf}}
 
 {{#description}}
 /**
@@ -46,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/modelOneOf.mustache

@@ -1,11 +1,3 @@
-{{#hasImports}}
-import {
-    {{#imports}}
-    {{{.}}}{{importFileExtension}},
-    {{/imports}}
-} from './';
-
-{{/hasImports}}
 /**
  * @type {{classname}}
  * Type
@@ -37,4 +29,16 @@ export class {{classname}}Class {
 
     static readonly mapping: {[index: string]: string} | undefined = undefined;
     {{/hasDiscriminatorWithNonEmptyMapping}}
+
+    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 {
+        return findMatchingType(data, this.arrayOfTypes);
+    }
 }

modules/openapi-generator/src/test/resources/3_0/typescript/oneOf.yaml

@@ -0,0 +1,62 @@
+openapi: 3.0.0
+info:
+  version: 1.0.0
+  title: testing oneOf
+servers:
+  - url: http://localhost:3000
+paths:
+  /test:
+    get:
+      operationId: testWithoutDiscriminator
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/PetResponse'
+  /test-discriminator:
+    get:
+      operationId: testDiscriminator
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/PetDiscriminatorResponse'
+components:
+  schemas:
+    PetDiscriminatorResponse:
+      discriminator:
+        propertyName: petType
+        mapping:
+          cat: "#/components/schemas/Cat"
+          dog: "#/components/schemas/Dog"
+      oneOf:
+        - $ref: "#/components/schemas/Cat"
+        - $ref: "#/components/schemas/Dog"
+    PetResponse:
+      oneOf:
+        - $ref: "#/components/schemas/Cat"
+        - $ref: "#/components/schemas/Dog"
+    Cat:
+      type: object
+      properties:
+        name:
+          type: string
+        petType:
+          type: string
+      required:
+        - name
+        - petType
+    Dog:
+      type: object
+      properties:
+        bark:
+          type: string
+        petType:
+          type: string
+      required:
+        - bark
+        - petType