Discriminator field is added to type with union instead of extending it

[stoilsky]

Consider the following bit that's part of a swagger.yml schema:

Order:
type: object
oneOf:
- $ref: '#/components/schemas/OrderByQuantity'
- $ref: '#/components/schemas/OrderByValue'
discriminator:
propertyName: type
mapping:
quantity: '#/components/schemas/OrderByQuantity'
value: '#/components/schemas/OrderByValue'
required:
- type
properties:
type:
type: string
description: Identifies whether the order has been placed by quantity (kg CO2) or value (monetary amount)
example: quantity
enum:
- quantity
- value

When I use openapi-typescript-codegen to generate the TypeScript type I get:
export type Order = (OrderByQuantity | OrderByValue | { type: 'quantity' | 'value', });

This seems incorrect - it seems like {type: 'quantity' | 'value'} should extend the type instead:
export type Order = (OrderByQuantity | OrderByValue * { type: 'quantity' | 'value', });

For comparison, here's what i get when i use https://www.npmjs.com/package/openapi-typescript -->
readonly Order: ( | components["schemas"]["OrderByQuantity"] | components["schemas"]["OrderByValue"] ) & { /** Identifies whether the order has been placed by quantity (kg CO2) or value (monetary amount) */ readonly type: "quantity" | "value"; } & { readonly [key: string]: any };

[ferdikoomen]

@StoicH In general this might be correct, but looking at your example the practical output would be the same:

type OrderByQuantity = {
    type: 'quantity'
};

type OrderByValue = {
    type: 'value'
};

type OrderOptionA = (OrderByQuantity | OrderByValue | { type: 'quantity' | 'value' });
type OrderOptionB = (OrderByQuantity | OrderByValue) & ({ type: 'quantity' | 'value' });

const order1: OrderOptionA = { type: "quantity" };
const order2: OrderOptionA = { type: "value" };
const order3: OrderOptionA = { type: "wrong" };

const order4: OrderOptionB = { type: "quantity" };
const order5: OrderOptionB = { type: "value" };
const order6: OrderOptionB = { type: "wrong" };

In this example both order3 and order6 will be wrong and others are valid, so it does not matter how you define this. The reason the pipe "|" is preferred is because of more common cases like:

type OrderOption = (OrderByQuantity | OrderByValue | { type: 'color' });

const order1: OrderOption = { type: "quantity" };
const order2: OrderOption = { type: "value" };
const order3: OrderOption = { type: "color" };
const order4: OrderOption = { type: "wrong" };

In this case the Order can be either OrderByQuantity , OrderByValue or an additional type (lets say OrderByColor). The first 3 will be correct and order4 will be incorrect. This is usually what we want.

[sjoerdmulder]

This might be solved by #741 which got merged yesterday with improves support for discriminator support