Ensure discriminator mappings use union enum literals

Resolve discriminator mapping generation to use literal values when
generateUnionEnums is enabled to avoid emitting enum member references.
Add regression coverage that snapshots the discriminator output with
union enums.

Signed-off-by: Sora Morimoto <sora@morimoto.io>

Author: smorimoto

.changeset/salty-pets-notice.md

@@ -0,0 +1,10 @@
+---
+"swagger-typescript-api": patch
+---
+
+Ensure discriminator mappings use union enum literals.
+
+Resolve discriminator mapping generation to use literal values when
+`generateUnionEnums` is enabled to avoid emitting enum member references.
+Add regression coverage that snapshots the discriminator output with
+union enums.

src/schema-parser/base-schema-parsers/discriminator.ts

@@ -177,18 +177,22 @@ export class DiscriminatorSchemaParser extends MonoSchemaParser {
       );
     }
 
-    if (
-      mappingPropertySchema?.rawTypeData?.$parsed?.type === SCHEMA_TYPES.ENUM
-    ) {
+    const parsedEnum = mappingPropertySchema?.rawTypeData?.$parsed;
+    if (parsedEnum?.type === SCHEMA_TYPES.ENUM) {
       mappingPropertySchemaEnumKeysMap = lodash.reduce(
-        mappingPropertySchema.rawTypeData.$parsed.enum,
+        parsedEnum.enum,
         (acc, key, index) => {
-          const enumKey =
-            mappingPropertySchema.rawTypeData.$parsed.content[index].key;
-          acc[key] = ts.EnumUsageKey(
-            mappingPropertySchema.rawTypeData.$parsed.typeName,
-            enumKey,
-          );
+          const enumContent = parsedEnum.content?.[index];
+          if (this.config.generateUnionEnums) {
+            const literalValue =
+              enumContent?.value ??
+              (key !== undefined ? ts.StringValue(key) : undefined);
+            if (literalValue !== undefined) {
+              acc[key] = literalValue;
+            }
+          } else if (parsedEnum.typeName && enumContent?.key) {
+            acc[key] = ts.EnumUsageKey(parsedEnum.typeName, enumContent.key);
+          }
           return acc;
         },
         {},

tests/spec/discriminator/__snapshots__/basic.test.ts.snap

@@ -236,3 +236,232 @@ type BaseBlockDtoWithEnumTypeMapping<Key, Type> = {
 } & Type;
 "
 `;
+
+exports[`basic > discriminator with union enums 1`] = `
+"/* eslint-disable */
+/* tslint:disable */
+// @ts-nocheck
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+
+export type PetEnum = "dog" | "lizard" | "cat";
+
+export type BlockDTOEnum = "csv" | "file" | "kek";
+
+/** kek pek */
+export type Variant =
+  | ({
+      type: "update";
+    } & VariantUpdate)
+  | ({
+      type: "undo";
+    } & VariantUndo)
+  | ({
+      type: "rollback";
+    } & VariantRollback)
+  | ({
+      type: "scale";
+    } & VariantScale)
+  | ({
+      type: "resources";
+    } & VariantResources)
+  | ({
+      type: "firewall";
+    } & VariantFirewall)
+  | ({
+      type: "gateway";
+    } & VariantGateway);
+
+export type InvalidDiscriminatorPropertyName =
+  BaseInvalidDiscriminatorPropertyName &
+    (
+      | BaseInvalidDiscriminatorPropertyNameTypeMapping<"num", number>
+      | BaseInvalidDiscriminatorPropertyNameTypeMapping<"str", string>
+    );
+
+export type PetWithEnum = BasePetWithEnum &
+  (
+    | BasePetWithEnumPetTypeMapping<"dog", DogWithEnum>
+    | BasePetWithEnumPetTypeMapping<"cat", CatWithEnum>
+    | BasePetWithEnumPetTypeMapping<"lizard", LizardWithEnum>
+  );
+
+export type PetOnlyDiscriminator =
+  | ({
+      pet_type: "dog";
+    } & Dog)
+  | ({
+      pet_type: "cat";
+    } & Cat)
+  | ({
+      pet_type: "lizard";
+    } & Lizard);
+
+export type Pet = BasePet &
+  (
+    | BasePetPetTypeMapping<"dog", Dog>
+    | BasePetPetTypeMapping<"cat", Cat>
+    | BasePetPetTypeMapping<"lizard", Lizard>
+  );
+
+export type BlockDTO = BaseBlockDto &
+  (
+    | BaseBlockDtoTypeMapping<"csv", CsvBlockDTO>
+    | BaseBlockDtoTypeMapping<"file", FileBlockDTO>
+  );
+
+export type BlockDTOWithEnum = BaseBlockDtoWithEnum &
+  (
+    | BaseBlockDtoWithEnumTypeMapping<"csv", CsvBlockWithEnumDTO>
+    | BaseBlockDtoWithEnumTypeMapping<"file", FileBlockWithEnumDTO>
+  );
+
+export type SimpleDiscriminator = SimpleObject | ComplexObject;
+
+export interface SimpleObject {
+  objectType: string;
+}
+
+export interface ComplexObject {
+  objectType: string;
+}
+
+export type CsvBlockWithEnumDTO = BaseBlockDtoWithEnum & {
+  type: "csv";
+  text: string;
+};
+
+export type FileBlockWithEnumDTO = BaseBlockDtoWithEnum & {
+  type: "file";
+  fileId: string;
+};
+
+export type CsvBlockDTO = BaseBlockDto & {
+  /** @default "csv" */
+  type: "csv";
+  text: string;
+};
+
+export type FileBlockDTO = BaseBlockDto & {
+  /** @default "file" */
+  type: "file";
+  fileId: string;
+};
+
+export type Cat = BasePet & {
+  name?: string;
+};
+
+export type Dog = BasePet & {
+  bark?: string;
+};
+
+export type Lizard = BasePet & {
+  lovesRocks?: boolean;
+};
+
+export type CatWithEnum = BasePetWithEnum & {
+  name?: string;
+};
+
+export type DogWithEnum = BasePetWithEnum & {
+  bark?: string;
+};
+
+export type LizardWithEnum = BasePetWithEnum & {
+  lovesRocks?: boolean;
+};
+
+/** Proposal to change firewall rules for deployment. */
+export interface VariantFirewall {
+  /** asdasdasdasdasdsad added to deployment. If not set, no rules are added. */
+  rules_added?: string[];
+  /** asdasdasdasdasdsad removed from deployment. If not set, no rules were removed. */
+  rules_removed?: string[];
+}
+
+/** asdasdasdasdasd */
+export interface VariantScale {
+  /**
+   * asdasdasdasdasdsad
+   * @example 3
+   */
+  replicas: number;
+}
+
+/** asdasdasdasdasd */
+export interface VariantResources {
+  resources: string;
+}
+
+/** asdasdasdasdasd */
+export interface VariantGateway {
+  /** asdasdasdasdasdsad */
+  port?: string;
+  /** asdasdasdasdasdsad */
+  name?: string;
+  /** asdasdasdasdasdsad */
+  domain?: string;
+}
+
+/** Pasdasdasdasdasd. */
+export type VariantUpdate = object;
+
+/** asdasdasdasdasd */
+export interface VariantRollback {
+  /**
+   * asdasdasdasdasdsad
+   * @example 42
+   */
+  revision_id: number;
+}
+
+/** asdasdasdasdasdn */
+export type VariantUndo = object;
+
+type BaseInvalidDiscriminatorPropertyName = object;
+
+type BaseInvalidDiscriminatorPropertyNameTypeMapping<Key, Type> = {
+  "@type": Key;
+} & Type;
+
+interface BasePetWithEnum {
+  pet_type: PetEnum;
+}
+
+type BasePetWithEnumPetTypeMapping<Key, Type> = {
+  pet_type: Key;
+} & Type;
+
+interface BasePet {
+  pet_type: string;
+}
+
+type BasePetPetTypeMapping<Key, Type> = {
+  pet_type: Key;
+} & Type;
+
+interface BaseBlockDto {
+  title: string;
+}
+
+type BaseBlockDtoTypeMapping<Key, Type> = {
+  type: Key;
+} & Type;
+
+interface BaseBlockDtoWithEnum {
+  title: string;
+  type: BlockDTOEnum;
+}
+
+type BaseBlockDtoWithEnumTypeMapping<Key, Type> = {
+  type: Key;
+} & Type;
+"
+`;

tests/spec/discriminator/basic.test.ts

@@ -31,4 +31,22 @@ describe("basic", async () => {
 
     expect(content).toMatchSnapshot();
   });
+
+  test("discriminator with union enums", async () => {
+    await generateApi({
+      fileName: "schema",
+      input: path.resolve(import.meta.dirname, "schema.json"),
+      output: tmpdir,
+      silent: true,
+      addReadonly: true,
+      generateClient: false,
+      generateUnionEnums: true,
+    });
+
+    const content = await fs.readFile(path.join(tmpdir, "schema.ts"), {
+      encoding: "utf8",
+    });
+
+    expect(content).toMatchSnapshot();
+  });
 });