Incorrect Type Generation for Discriminator Mappings: Common Schema Discriminator Values Not Fully Propagated

[Omarov3000]

Description

When using a discriminator where multiple mapping keys (e.g., "approval_policy" and "entity") point to the same common schema, the generated TypeScript types incorrectly narrow the allowed discriminator values to only one representative (in this case, "approval_policy").

Reproducible example or configuration

npx @hey-api/openapi-ts \
  -i https://pub-32c654c6a381482f95842971390c1d2f.r2.dev/gh-issues/discriminator-bug.yaml \
  -o src \
  -c @hey-api/client-fetch

generated:

export type RootSchemaInput = ({
    object_type?: 'approval_policy';
} & CommonSchemaInput) | ({
    object_type?: 'payable';
} & PayableSchemaInput);

export type CommonSchemaInput = {
    object_type?: 'approval_policy' | 'entity';
};

export type PayableSchemaInput = {
    object_type?: 'payable';
};

expected

export type RootSchemaInput = ({
    object_type: 'approval_policy' | 'entity';
} & CommonSchemaInput) | ({
    object_type: 'payable';
} & PayableSchemaInput);

export type CommonSchemaInput = {
    object_type: 'approval_policy' | 'entity';
};

export type PayableSchemaInput = {
    object_type: 'payable';
};

OpenAPI specification (optional)

openapi: "3.0.3"
info:
  title: Minimal Discriminator Example
  version: "1.0"
paths: {}
components:
  schemas:
    RootSchemaInput:
      oneOf:
        - $ref: "#/components/schemas/CommonSchemaInput"
        - $ref: "#/components/schemas/PayableSchemaInput"
      discriminator:
        propertyName: object_type
        mapping:
          approval_policy: "#/components/schemas/CommonSchemaInput"
          entity: "#/components/schemas/CommonSchemaInput"
          payable: "#/components/schemas/PayableSchemaInput"
    CommonSchemaInput:
      type: object
      properties:
        object_type:
          type: string
          enum:
            - approval_policy
            - entity
    PayableSchemaInput:
      type: object
      properties:
        object_type:
          type: string
          enum:
            - payable

System information (optional)

"@hey-api/openapi-ts": "^0.65.0"

[Omarov3000]

Note: the same issue happens for both: input and output

[Omarov3000]

Probably duplicate of #1805 but with a bit easier reproduction

[mrlubos]

Yep! Thanks for flagging

[artursberezjuks-odido]

hello @mrlubos
wasn't able to create pr against your repo but we also had this issue

so solutions that worked for me is here

packages/openapi-ts/src/openApi/3.1.x/parser/schema.ts (version 0.66.6)

line 519

const parseAnyOf = ({
  context,
  schema,
  state,
}: {
  context: IR.Context;
  schema: SchemaWithRequired<SchemaObject, 'anyOf'>;
  state: SchemaState;
}): IR.SchemaObject => {
  let irSchema = initIrSchema({ schema });

  const schemaItems: Array<IR.SchemaObject> = [];
  const schemaTypes = getSchemaTypes({ schema });

  const compositionSchemas = schema.anyOf;

  for (const compositionSchema of compositionSchemas) {
    let irCompositionSchema = schemaToIrSchema({
      context,
      schema: compositionSchema,
      state,
    });

    irSchema.accessScopes = mergeSchemaAccessScopes(
      irSchema.accessScopes,
      irCompositionSchema.accessScopes,
    );

    // `$ref` should be defined with discriminators
    if (schema.discriminator && compositionSchema.$ref) {
// start of fix 👇👇👇👇👇👇👇👇👇👇👇👇
      const ref = compositionSchema.$ref;
      const possibleValues = Object.entries(schema.discriminator?.mapping ?? {})
        .filter(([, value]) => value === ref)
        .map(([key]) => key);

      if (possibleValues.length === 0) {
        throw new Error(`No discriminator mapping found for $ref: ${ref}`);
      }

      const discriminatorProperty: Partial<IRSchemaObject> = {};
      if (possibleValues.length === 1) {
        discriminatorProperty.type = 'string';
        discriminatorProperty.const = possibleValues[0];
      } else {
        discriminatorProperty.type = 'enum';
        discriminatorProperty.logicalOperator = 'or';
        discriminatorProperty.items = possibleValues.map((value) => ({
          const: value,
          type: 'string',
        }));
      }

      const irDiscriminatorSchema: IR.SchemaObject = {
        properties: {
          [schema.discriminator.propertyName]: discriminatorProperty,
        },
// end of fix 👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆
        type: 'object',
      };
      irCompositionSchema = {
        items: [irDiscriminatorSchema, irCompositionSchema],
        logicalOperator: 'and',
      };
    }

    schemaItems.push(irCompositionSchema);
  }

  if (schemaTypes.includes('null')) {
    schemaItems.push({ type: 'null' });
  }

  irSchema = addItemsToSchema({
    items: schemaItems,
    mutateSchemaOneItem: true,
    schema: irSchema,
  });

  if (schemaTypes.includes('object')) {
    // nest composition to avoid producing a union with object properties
    const irObjectSchema = parseOneType({
      context,
      schema: {
        ...schema,
        type: 'object',
      },
      state,
    });

    irSchema.accessScopes = mergeSchemaAccessScopes(
      irSchema.accessScopes,
      irObjectSchema.accessScopes,
    );

    if (irObjectSchema.properties) {
      irSchema = {
        items: [irSchema, irObjectSchema],
        logicalOperator: 'and',
      };
    }
  }

  return irSchema;
};

i see that there are at least 10 places where it should be adjusted to fit both singular and multiple same ref discriminator's , but for now i will just patch package and live on this fix

[artursberezjuks-odido]

also added gist with my fix
https://gist.github.com/artursberezjuks-odido/f10443652123a274cc09d86191c1dccd

[mrlubos]

@artursberezjuks-odido @Omarov3000 no more workarounds needed in v0.66.7! 🤝