[TypeScript] Implement oneOf type resolution without discriminator

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

@@ -50,6 +50,7 @@
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import static org.openapitools.codegen.utils.CamelizeOption.LOWERCASE_FIRST_LETTER;
 import static org.openapitools.codegen.utils.OnceLogger.once;
@@ -174,6 +175,9 @@ 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"));
+        supportingFiles.add(new SupportingFile("model" + File.separator + "ModelTypes.mustache", "models", "ModelTypes.ts"));
+
         modelTemplateFiles.put("model" + File.separator + "model.mustache", ".ts");
 
         // api
@@ -360,12 +364,22 @@ private String getNameWithEnumPropertyNaming(String name) {
         }
     }
 
+    @Override
+    public CodegenModel fromModel(String name, Schema schema) {
+        CodegenModel codegenModel = super.fromModel(name, schema);
+        return new ExtendedCodegenModel(codegenModel);
+    }
+
     @Override
     public ModelsMap postProcessModels(ModelsMap objs) {
         // process enum in models
         List<ModelMap> models = postProcessModelsEnum(objs).getModels();
         for (ModelMap mo : models) {
-            CodegenModel cm = mo.getModel();
+            CodegenModel model = mo.getModel();
+            // Convert to ExtendedCodegenModel if it's not already one (e.g., in tests)
+            ExtendedCodegenModel cm = model instanceof ExtendedCodegenModel
+                ? (ExtendedCodegenModel) model
+                : new ExtendedCodegenModel(model);
             cm.imports = new TreeSet<>(cm.imports);
             // name enum with model name, e.g. StatusEnum => Pet.StatusEnum
             for (CodegenProperty var : cm.vars) {
@@ -381,15 +395,37 @@ public ModelsMap postProcessModels(ModelsMap objs) {
                     }
                 }
             }
+
+            List<CodegenProperty> oneOfsList = Optional.ofNullable(cm.getComposedSchemas())
+                    .map(CodegenComposedSchemas::getOneOf)
+                    .orElse(Collections.emptyList());
+
+            // create a set of any non-primitive, non-array types used in the oneOf schemas which will
+            // need to be imported.
+            cm.oneOfModels = oneOfsList.stream()
+                    .filter(cp -> !cp.getIsPrimitiveType() && !cp.getIsArray())
+                    .map(CodegenProperty::getBaseType)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toCollection(TreeSet::new));
+
+            // create a set of any complex, inner types used by arrays in the oneOf schema (e.g. if
+            // the oneOf uses Array<Foo>, Foo needs to be imported).
+            cm.oneOfArrays = oneOfsList.stream()
+                    .filter(CodegenProperty::getIsArray)
+                    .map(CodegenProperty::getComplexType)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toCollection(TreeSet::new));
+
+            // create a set of primitive types used in the oneOf schemas for the deserialization process.
+            cm.oneOfPrimitives = oneOfsList.stream()
+                    .filter(CodegenProperty::getIsPrimitiveType)
+                    .collect(Collectors.toCollection(HashSet::new));
+
             if (!cm.oneOf.isEmpty()) {
                 // For oneOfs only import $refs within the oneOf
-                TreeSet<String> oneOfRefs = new TreeSet<>();
-                for (String im : cm.imports) {
-                    if (cm.oneOf.contains(im)) {
-                        oneOfRefs.add(im);
-                    }
-                }
-                cm.imports = oneOfRefs;
+                cm.imports = cm.imports.stream()
+                        .filter(im -> cm.oneOfModels.contains(im) || cm.oneOfArrays.contains(im))
+                        .collect(Collectors.toCollection(TreeSet::new));
             }
         }
         for (ModelMap mo : models) {
@@ -1117,4 +1153,111 @@ protected void addImport(Set<String> importsToBeAddedTo, String type) {
     protected String[] splitComposedTypes(String type) {
         return type.replace(" ", "").split("[|&<>]");
     }
+
+    public class ExtendedCodegenModel extends CodegenModel {
+        // oneOfModels contains a list of non-primitive, non-array types referenced in oneOf schemas that need to be
+        // imported.
+        // oneOfArrays contains a list of complex inner types used in arrays within oneOf schemas (e.g. if
+        // oneOf uses Array<Foo>, Foo needs to be imported).
+        // oneOfPrimitives contains a list of primitive types used in oneOf schemas for the deserialization process.
+        @Getter @Setter
+        public Set<String> oneOfModels = new TreeSet<>();
+        @Getter @Setter
+        public Set<String> oneOfArrays = new TreeSet<>();
+        @Getter @Setter
+        public Set<CodegenProperty> oneOfPrimitives = new HashSet<>();
+
+        public ExtendedCodegenModel(CodegenModel cm) {
+            super();
+
+            this.parent = cm.parent;
+            this.parentSchema = cm.parentSchema;
+            this.interfaces = cm.interfaces;
+            this.allParents = cm.allParents;
+            this.parentModel = cm.parentModel;
+            this.interfaceModels = cm.interfaceModels;
+            this.children = cm.children;
+            this.anyOf = cm.anyOf;
+            this.oneOf = cm.oneOf;
+            this.allOf = cm.allOf;
+            this.permits = cm.permits;
+            this.name = cm.name;
+            this.schemaName = cm.schemaName;
+            this.classname = cm.classname;
+            this.title = cm.title;
+            this.description = cm.description;
+            this.classVarName = cm.classVarName;
+            this.modelJson = cm.modelJson;
+            this.dataType = cm.dataType;
+            this.xmlPrefix = cm.xmlPrefix;
+            this.xmlNamespace = cm.xmlNamespace;
+            this.xmlName = cm.xmlName;
+            this.classFilename = cm.classFilename;
+            this.unescapedDescription = cm.unescapedDescription;
+            this.defaultValue = cm.defaultValue;
+            this.arrayModelType = cm.arrayModelType;
+            this.isAlias = cm.isAlias;
+            this.isString = cm.isString;
+            this.isInteger = cm.isInteger;
+            this.isLong = cm.isLong;
+            this.isNumber = cm.isNumber;
+            this.isNumeric = cm.isNumeric;
+            this.isFloat = cm.isFloat;
+            this.isDouble = cm.isDouble;
+            this.isDate = cm.isDate;
+            this.isDateTime = cm.isDateTime;
+            this.vars = cm.vars;
+            this.allVars = cm.allVars;
+            this.requiredVars = cm.requiredVars;
+            this.optionalVars = cm.optionalVars;
+            this.hasReadOnly = cm.hasReadOnly;
+            this.readOnlyVars = cm.readOnlyVars;
+            this.readWriteVars = cm.readWriteVars;
+            this.parentVars = cm.parentVars;
+            this.parentRequiredVars = cm.parentRequiredVars;
+            this.nonNullableVars = cm.nonNullableVars;
+            this.allowableValues = cm.allowableValues;
+            this.mandatory = cm.mandatory;
+            this.allMandatory = cm.allMandatory;
+            this.imports = cm.imports;
+            this.hasVars = cm.hasVars;
+            this.emptyVars = cm.emptyVars;
+            this.hasMoreModels = cm.hasMoreModels;
+            this.hasEnums = cm.hasEnums;
+            this.isEnum = cm.isEnum;
+            this.hasValidation = cm.hasValidation;
+            this.isNullable = cm.isNullable;
+            this.hasRequired = cm.hasRequired;
+            this.hasOptional = cm.hasOptional;
+            this.isArray = cm.isArray;
+            this.hasChildren = cm.hasChildren;
+            this.isMap = cm.isMap;
+            this.isDeprecated = cm.isDeprecated;
+            this.hasOnlyReadOnly = cm.hasOnlyReadOnly;
+            this.externalDocumentation = cm.externalDocumentation;
+
+            this.vendorExtensions = cm.vendorExtensions;
+            this.additionalPropertiesType = cm.additionalPropertiesType;
+            this.isAdditionalPropertiesTrue = cm.isAdditionalPropertiesTrue;
+            this.setMaxProperties(cm.getMaxProperties());
+            this.setMinProperties(cm.getMinProperties());
+            this.setUniqueItems(cm.getUniqueItems());
+            this.setMaxItems(cm.getMaxItems());
+            this.setMinItems(cm.getMinItems());
+            this.setMaxLength(cm.getMaxLength());
+            this.setMinLength(cm.getMinLength());
+            this.setExclusiveMinimum(cm.getExclusiveMinimum());
+            this.setExclusiveMaximum(cm.getExclusiveMaximum());
+            this.setMinimum(cm.getMinimum());
+            this.setMaximum(cm.getMaximum());
+            this.setPattern(cm.getPattern());
+            this.setMultipleOf(cm.getMultipleOf());
+            this.setItems(cm.getItems());
+            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,26 +127,37 @@ 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.
-            } 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
+            if (discriminatorProperty == null || !data[discriminatorProperty]) {
+                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 {
+                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}'.`);
                 }
             }
         }
     }
 
+    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,36 @@
+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<AttributeTypeMapEntry>): boolean {
+    for (const attribute of attributeTypeMap) {
+        if (attribute.required && 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

@@ -1,9 +1,14 @@
 {{>licenseInfo}}
 {{#models}}
 {{#model}}
+{{#oneOf}}
+{{#-first}}{{>model/modelOneOf}}{{/-first}}
+{{/oneOf}}
+{{^oneOf}}
 {{#tsImports}}
 import { {{classname}} } from '{{filename}}{{importFileExtension}}';
 {{/tsImports}}
+import { AttributeTypeMapEntry } from '../models/ModelTypes{{importFileExtension}}';
 import { HttpFile } from '../http/http{{importFileExtension}}';
 
 {{#description}}
@@ -12,10 +17,6 @@ import { HttpFile } from '../http/http{{importFileExtension}}';
 */
 {{/description}}
 {{^isEnum}}
-{{#oneOf}}
-{{#-first}}{{>model/modelOneOf}}{{/-first}}
-{{/oneOf}}
-{{^oneOf}}
 export class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
 {{#vars}}
 {{#description}}
@@ -46,13 +47,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<AttributeTypeMapEntry> = [
         {{#vars}}
         {
             "name": "{{name}}",
             "baseName": "{{baseName}}",
             "type": "{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}",
-            "format": "{{dataFormat}}"
+            "format": "{{dataFormat}}",
+            "required": {{required}}
         }{{^-last}},
         {{/-last}}
         {{/vars}}
@@ -97,7 +99,6 @@ export enum {{classname}}{{enumName}} {
 {{/vars}}
 
 {{/hasEnums}}
-{{/oneOf}}
 {{/isEnum}}
 {{#isEnum}}
 export enum {{classname}} {
@@ -108,5 +109,6 @@ export enum {{classname}} {
     {{/allowableValues}}
 }
 {{/isEnum}}
+{{/oneOf}}
 {{/model}}
 {{/models}}

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

@@ -1,11 +1,8 @@
-{{#hasImports}}
-import {
-    {{#imports}}
-    {{{.}}}{{importFileExtension}},
-    {{/imports}}
-} from './';
+{{#tsImports}}
+import { {{classname}} } from '{{filename}}{{importFileExtension}}';
+{{/tsImports}}
+import { findMatchingType } from '../models/TypeMatcher{{importFileExtension}}';
 
-{{/hasImports}}
 /**
  * @type {{classname}}
  * Type
@@ -37,4 +34,16 @@ export class {{classname}}Class {
 
     static readonly mapping: {[index: string]: string} | undefined = undefined;
     {{/hasDiscriminatorWithNonEmptyMapping}}
+
+    private static readonly arrayOfTypes: Array<{{#oneOfModels}}typeof {{{.}}}{{^-last}} | {{/-last}}{{/oneOfModels}}> = [{{#oneOfModels}}{{{.}}}{{^-last}}, {{/-last}}{{/oneOfModels}}];
+
+    /**
+     * 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);
+    }
 }