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

[guizmaii]

Problem

When an OpenAPI spec declares the discriminator property on each variant schema (as a required single-value enum -- which is the correct behavior per the OpenAPI 3.x spec), the typescript-fetch generator produces union types with intersection wrappers that break TypeScript compilation.

OpenAPI spec:

components:
  schemas:
    Authentication:
      oneOf:
        - $ref: '#/components/schemas/ApiKey'
        - $ref: '#/components/schemas/Basic'
      discriminator:
        propertyName: type
        mapping:
          APIKEY: '#/components/schemas/ApiKey'
          BASIC: '#/components/schemas/Basic'

    ApiKey:
      type: object
      required: [type, apiKey]
      properties:
        type:
          type: string
          enum: [APIKEY]       # discriminator as single-value enum
        apiKey:
          type: string

    Basic:
      type: object
      required: [type, username, password]
      properties:
        type:
          type: string
          enum: [BASIC]        # discriminator as single-value enum
        username:
          type: string
        password:
          type: string

Generated code (broken):

// models/ApiKey.ts -- generated enum for the discriminator property
export const ApiKeyTypeEnum = { Apikey: 'APIKEY' } as const;
export type ApiKeyTypeEnum = typeof ApiKeyTypeEnum[keyof typeof ApiKeyTypeEnum];

export interface ApiKey {
    type: ApiKeyTypeEnum;   // ApiKeyTypeEnum, not a string literal
    apiKey: string;
}

// models/Authentication.ts -- intersection wrapper duplicates the discriminator
export type Authentication =
  | { type: 'APIKEY' } & ApiKey
  | { type: 'BASIC' } & Basic;

The intersection { type: 'APIKEY' } & ApiKey requires type to be both the string literal 'APIKEY' and ApiKeyTypeEnum simultaneously. TypeScript treats string literals and const enum members as distinct nominal types, so 'APIKEY' & ApiKeyTypeEnum evaluates to never. This collapses the discriminant property to never, making the entire branch of the union uninhabitable:

// What TypeScript actually sees after type reduction:
type Authentication =
  | { type: never; apiKey: string }     // can never be constructed
  | { type: never; username: string; password: string };

// Downstream code breaks:
const auth: Authentication = {
  type: 'APIKEY',  // Error: Type '"APIKEY"' is not assignable to type 'never'
  apiKey: 'secret',
};

This happens whenever variant schemas correctly include the discriminator as a required property -- which is the valid approach per the OpenAPI 3.x spec.

Solution

In TypeScriptFetchClientCodegen.postProcessAllModels(), detect when all discriminator variant models already declare the discriminator as a required property. When they do, set a vendor extension flag (x-variants-have-discriminator) on the discriminator.

The Mustache templates (modelOneOfInterfaces.mustache, modelOneOf.mustache) then conditionally:

• Emit simple unions (ApiKey | Basic) instead of intersection wrappers ({ type: 'APIKEY' } & ApiKey)
• Delegate directly to variant FromJSONTyped/ToJSON instead of using Object.assign with literal wrappers

Generated code (fixed):

// Simple union -- no intersection, no type conflict
export type Authentication = ApiKey | Basic;

// FromJSON uses direct delegation
export function AuthenticationFromJSONTyped(json: any, ignoreDiscriminator: boolean): Authentication {
    if (json == null) { return json; }
    switch (json['type']) {
        case 'APIKEY':
            return ApiKeyFromJSONTyped(json, true);
        case 'BASIC':
            return BasicFromJSONTyped(json, true);
        default:
            return json;
    }
}

Backward compatibility: When variants do NOT have the discriminator property (legacy/non-compliant specs), the intersection wrapper behavior is preserved unchanged.

Test plan

• Updated existing testOneOfModelsDoNotImportPrimitiveTypes test -- the existing oneOf.yaml spec already has variants with discriminator properties (OptionOne.discriminatorField), so the test now correctly asserts simple unions
• Added testDiscriminatorWithoutPropertyOnVariantsUsesIntersectionWrapper test with a new spec (discriminator-without-property.yaml) to verify backward compatibility
• All 23 TypeScriptFetchClientCodegenTest tests pass

[cubic-dev-ai]

1 issue found across 5 files

Prompt for AI agents (unresolved issues)

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptFetchClientCodegen.java">

<violation number="1" location="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptFetchClientCodegen.java:497">
P2: Discriminator-variant detection ignores requiredness, so optional discriminator fields can wrongly enable simple-union generation and altered JSON conversion behavior.</violation>
</file>

---

Since this is your first cubic review, here's how it works:

• cubic automatically reviews your code and comments on bugs and improvements
• Teach cubic by replying to its comments. cubic learns from your replies and gets better over time
• Add one-off context when rerunning by tagging @cubic-dev-ai with guidance or docs links (including llms.txt)
• Ask questions if you need clarification on any suggestion

_{Reply with feedback, questions, or to request a fix. Tag @cubic-dev-ai to re-run a review.}