fix(typescript-fetch): use simple union when variants already declare discriminator property

When an OpenAPI spec declares the discriminator property on each variant
schema (e.g., as a single-value enum), the generated TypeScript union type
should use a simple union (ApiKey | Basic) instead of intersection wrappers
({ type: 'APIKEY' } & ApiKey).

The intersection wrapper causes TypeScript to evaluate
'APIKEY' & ApiKeyTypeEnum as never (string literals and string enums are
distinct nominal types), collapsing the entire union to never. This breaks
all downstream code that references the union type.

The fix detects when all discriminator variant models already have the
discriminator as a required property and sets a vendor extension flag
(x-variants-have-discriminator) on the discriminator. The templates then
conditionally skip the intersection wrapper and Object.assign calls when
this flag is set.

Backward compatibility: when variants do NOT have the discriminator
property (legacy specs), the intersection wrapper behavior is preserved.

Author: guizmaii

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

@@ -475,6 +475,40 @@ public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs)
                 }
             }
         }
+
+        // Detect if discriminator variants already declare the discriminator property.
+        // When they do, the union type should use simple unions (e.g., ApiKey | Basic)
+        // instead of intersection wrappers (e.g., { type: 'APIKEY' } & ApiKey), because
+        // the intersection of a string literal with a string enum evaluates to `never`
+        // in TypeScript when stringEnums is enabled.
+        for (ExtendedCodegenModel rootModel : allModels) {
+            CodegenDiscriminator discriminator = rootModel.discriminator;
+            if (discriminator == null || discriminator.getMappedModels() == null
+                    || discriminator.getMappedModels().isEmpty()) {
+                continue;
+            }
+            String discPropBaseName = discriminator.getPropertyBaseName();
+            boolean allVariantsHaveDiscriminator = true;
+            for (CodegenDiscriminator.MappedModel mm : discriminator.getMappedModels()) {
+                boolean variantHasProp = false;
+                for (ExtendedCodegenModel model : allModels) {
+                    if (model.classname.equals(mm.getModelName())) {
+                        variantHasProp = model.vars.stream()
+                                .anyMatch(v -> v.baseName.equals(discPropBaseName));
+                        break;
+                    }
+                }
+                if (!variantHasProp) {
+                    allVariantsHaveDiscriminator = false;
+                    break;
+                }
+            }
+            if (allVariantsHaveDiscriminator) {
+                discriminator.getVendorExtensions()
+                        .put("x-variants-have-discriminator", true);
+            }
+        }
+
         return result;
     }
 

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

@@ -34,7 +34,12 @@ export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boole
     switch (json['{{discriminator.propertyBaseName}}']) {
 {{#discriminator.mappedModels}}
         case '{{mappingName}}':
+{{#discriminator.vendorExtensions.x-variants-have-discriminator}}
+            return {{modelName}}FromJSONTyped(json, true);
+{{/discriminator.vendorExtensions.x-variants-have-discriminator}}
+{{^discriminator.vendorExtensions.x-variants-have-discriminator}}
             return Object.assign({}, {{modelName}}FromJSONTyped(json, true), { {{discriminator.propertyName}}: '{{mappingName}}' } as const);
+{{/discriminator.vendorExtensions.x-variants-have-discriminator}}
 {{/discriminator.mappedModels}}
         default:
             return json;
@@ -151,7 +156,12 @@ export function {{classname}}ToJSONTyped(value?: {{classname}} | null, ignoreDis
     switch (value['{{discriminator.propertyName}}']) {
 {{#discriminator.mappedModels}}
         case '{{mappingName}}':
+{{#discriminator.vendorExtensions.x-variants-have-discriminator}}
+            return {{modelName}}ToJSON(value);
+{{/discriminator.vendorExtensions.x-variants-have-discriminator}}
+{{^discriminator.vendorExtensions.x-variants-have-discriminator}}
             return Object.assign({}, {{modelName}}ToJSON(value), { {{discriminator.propertyName}}: '{{mappingName}}' } as const);
+{{/discriminator.vendorExtensions.x-variants-have-discriminator}}
 {{/discriminator.mappedModels}}
         default:
             return value;

modules/openapi-generator/src/main/resources/typescript-fetch/modelOneOfInterfaces.mustache

@@ -3,4 +3,4 @@
  * {{#lambda.indented_star_1}}{{{unescapedDescription}}}{{/lambda.indented_star_1}}
  * @export
  */
-export type {{classname}} = {{#discriminator}}{{#mappedModels}}{ {{discriminator.propertyName}}: '{{mappingName}}' } & {{modelName}}{{^-last}} | {{/-last}}{{/mappedModels}}{{/discriminator}}{{^discriminator}}{{#oneOf}}{{{.}}}{{^-last}} | {{/-last}}{{/oneOf}}{{/discriminator}};
+export type {{classname}} = {{#discriminator}}{{#vendorExtensions.x-variants-have-discriminator}}{{#mappedModels}}{{modelName}}{{^-last}} | {{/-last}}{{/mappedModels}}{{/vendorExtensions.x-variants-have-discriminator}}{{^vendorExtensions.x-variants-have-discriminator}}{{#mappedModels}}{ {{discriminator.propertyName}}: '{{mappingName}}' } & {{modelName}}{{^-last}} | {{/-last}}{{/mappedModels}}{{/vendorExtensions.x-variants-have-discriminator}}{{/discriminator}}{{^discriminator}}{{#oneOf}}{{{.}}}{{^-last}} | {{/-last}}{{/oneOf}}{{/discriminator}};

modules/openapi-generator/src/test/java/org/openapitools/codegen/typescript/fetch/TypeScriptFetchClientCodegenTest.java

@@ -403,7 +403,14 @@ public void testOneOfModelsDoNotImportPrimitiveTypes() throws IOException {
         TestUtils.assertFileExists(testDiscriminatorResponse);
         TestUtils.assertFileContains(testDiscriminatorResponse, "import type { OptionOne } from './OptionOne'");
         TestUtils.assertFileContains(testDiscriminatorResponse, "import type { OptionTwo } from './OptionTwo'");
-        TestUtils.assertFileContains(testDiscriminatorResponse, "export type TestDiscriminatorResponse = { discriminatorField: 'optionOne' } & OptionOne | { discriminatorField: 'optionTwo' } & OptionTwo");
+        // When variants already declare the discriminator property (OptionOne/OptionTwo have
+        // discriminatorField as a required single-value enum), the union should use simple types
+        // instead of intersection wrappers to avoid TypeScript `never` type issues with string enums
+        TestUtils.assertFileContains(testDiscriminatorResponse, "export type TestDiscriminatorResponse = OptionOne | OptionTwo");
+        TestUtils.assertFileNotContains(testDiscriminatorResponse, "{ discriminatorField: 'optionOne' } & OptionOne");
+        // FromJSON should delegate directly without Object.assign wrapper
+        TestUtils.assertFileContains(testDiscriminatorResponse, "return OptionOneFromJSONTyped(json, true)");
+        TestUtils.assertFileNotContains(testDiscriminatorResponse, "Object.assign");
     }
 
     /**
@@ -444,6 +451,21 @@ public void testOneOfModelsImportNonPrimitiveTypes() throws IOException {
         TestUtils.assertFileContains(testResponse, "import type { OptionThree } from './OptionThree'");
     }
 
+    @Test(description = "Verify discriminator uses intersection wrappers when variants do NOT have discriminator property")
+    public void testDiscriminatorWithoutPropertyOnVariantsUsesIntersectionWrapper() throws IOException {
+        File output = generate(
+            Collections.emptyMap(),
+            "src/test/resources/3_0/typescript-fetch/discriminator-without-property.yaml"
+        );
+
+        Path shapePath = Paths.get(output + "/models/Shape.ts");
+        TestUtils.assertFileExists(shapePath);
+        // When variants don't have the discriminator property, intersection wrappers should be used
+        TestUtils.assertFileContains(shapePath, "{ shapeType: 'circle' } & Circle");
+        TestUtils.assertFileContains(shapePath, "{ shapeType: 'square' } & Square");
+        TestUtils.assertFileContains(shapePath, "Object.assign");
+    }
+
     @Test(description = "Verify validationAttributes works with withoutRuntimeChecks=true")
     public void testValidationAttributesWithWithoutRuntimeChecks() throws IOException {
         Map<String, Object> properties = new HashMap<>();

modules/openapi-generator/src/test/resources/3_0/typescript-fetch/discriminator-without-property.yaml

@@ -0,0 +1,40 @@
+openapi: 3.0.0
+info:
+  version: 1.0.0
+  title: testing discriminator when variants do NOT have discriminator property
+paths:
+  /test:
+    get:
+      operationId: test
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Shape'
+components:
+  schemas:
+    Shape:
+      discriminator:
+        propertyName: shapeType
+        mapping:
+          circle: "#/components/schemas/Circle"
+          square: "#/components/schemas/Square"
+      oneOf:
+        - $ref: "#/components/schemas/Circle"
+        - $ref: "#/components/schemas/Square"
+    Circle:
+      type: object
+      properties:
+        radius:
+          type: number
+      required:
+        - radius
+    Square:
+      type: object
+      properties:
+        side:
+          type: number
+      required:
+        - side