fix incorrect types generated when refs reference types with discriminators

Author: adamschoenemann

packages/openapi-typescript/src/transform/schema-object.ts

@@ -203,8 +203,8 @@ export function defaultSchemaObjectTransform(schemaObject: SchemaObject | Refere
         // Mapping value can either be a fully-qualified ref (#/components/schemas/XYZ) or a schema name (XYZ)
         const matchedValue = Object.entries(discriminator.mapping).find(([, v]) => (!v.startsWith("#") && v === value) || (v.startsWith("#") && parseRef(v).path.pop() === value));
         if (matchedValue) value = matchedValue[0]; // why was this designed backwards!?
+        coreType.unshift(indent(`${escObjKey(discriminator.propertyName)}: ${escStr(value)};`, indentLv + 1));
       }
-      coreType.unshift(indent(`${escObjKey(discriminator.propertyName)}: ${escStr(value)};`, indentLv + 1));
       break;
     }
   }
@@ -217,7 +217,7 @@ export function defaultSchemaObjectTransform(schemaObject: SchemaObject | Refere
     const output: string[] = [];
     for (const item of items) {
       const itemType = transformSchemaObject(item, { path, ctx: { ...ctx, indentLv } });
-      if ("$ref" in item && ctx.discriminators[item.$ref]) {
+      if ("$ref" in item && ctx.discriminators[item.$ref]?.mapping) {
         output.push(tsOmit(itemType, [ctx.discriminators[item.$ref].propertyName]));
         continue;
       }

packages/openapi-typescript/test/index.test.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
-import type { OpenAPI3 } from "../src/types.js";
 import openapiTS from "../dist/index.js";
+import type { OpenAPI3 } from "../src/types.js";
 
 const BOILERPLATE = `/**
  * This file was auto-generated by openapi-typescript.
@@ -457,7 +457,7 @@ export interface external {
 
 export type operations = Record<string, never>;
 `);
-    })
+    });
   });
 
   describe("3.1", () => {
@@ -546,7 +546,7 @@ export type operations = Record<string, never>;
 `);
     });
 
-    test("discriminator (oneOf)", async () => {
+    test("discriminator with explicit mapping (oneOf)", async () => {
       const schema: OpenAPI3 = {
         openapi: "3.1",
         info: { title: "test", version: "1.0" },
@@ -625,6 +625,93 @@ export interface components {
 
 export type external = Record<string, never>;
 
+export type operations = Record<string, never>;
+`);
+    });
+
+    test("discriminator with implicit mapping (oneOf)", async () => {
+      const schema: OpenAPI3 = {
+        openapi: "3.1",
+        info: { title: "test", version: "1.0" },
+        components: {
+          schemas: {
+            Pet: {
+              oneOf: [{ $ref: "#/components/schemas/Cat" }, { $ref: "#/components/schemas/Dog" }, { $ref: "#/components/schemas/Lizard" }],
+              discriminator: {
+                propertyName: "petType",
+              },
+            } as any,
+            Cat: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                petType: { type: "string", enum: ["cat"] },
+              },
+              required: ["petType"],
+            },
+            Dog: {
+              type: "object",
+              properties: {
+                bark: { type: "string" },
+                petType: { type: "string", enum: ["dog"] },
+              },
+              required: ["petType"],
+            },
+            Lizard: {
+              type: "object",
+              properties: {
+                lovesRocks: { type: "boolean" },
+                petType: { type: "string", enum: ["lizard"] },
+              },
+              required: ["petType"],
+            },
+            Person: {
+              type: "object",
+              required: ["pet"],
+              properties: {
+                pet: { oneOf: [{ $ref: "#/components/schemas/Pet" }] },
+              },
+            },
+          },
+        },
+      };
+      const generated = await openapiTS(schema);
+      expect(generated).toBe(`${BOILERPLATE}
+export type paths = Record<string, never>;
+
+export type webhooks = Record<string, never>;
+
+export interface components {
+  schemas: {
+    Pet: components["schemas"]["Cat"] | components["schemas"]["Dog"] | components["schemas"]["Lizard"];
+    Cat: {
+      name?: string;
+      /** @enum {string} */
+      petType: "cat";
+    };
+    Dog: {
+      bark?: string;
+      /** @enum {string} */
+      petType: "dog";
+    };
+    Lizard: {
+      lovesRocks?: boolean;
+      /** @enum {string} */
+      petType: "lizard";
+    };
+    Person: {
+      pet: components["schemas"]["Pet"];
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+
+export type external = Record<string, never>;
+
 export type operations = Record<string, never>;
 `);
     });

packages/openapi-typescript/test/schema-object.test.ts

@@ -374,48 +374,6 @@ describe("Schema Object", () => {
         expect(generated).toBe("0 | 1");
       });
 
-      test("empty object + oneOf is ignored", () => {
-        const schema: SchemaObject = {
-          type: "object",
-          oneOf: [
-            {
-              title: "DetailsId",
-              type: "object",
-              required: ["id"],
-              properties: {
-                id: { type: "string", description: "The ID of an existing resource that exists before the pipeline is run." },
-              },
-            },
-            {
-              title: "DetailsFrom",
-              type: "object",
-              required: ["from"],
-              properties: {
-                from: {
-                  type: "object",
-                  description: "The stage and step to report on.",
-                  required: ["step"],
-                  properties: { stage: { type: "string", description: "An identifier for the stage the step being reported on resides in." }, step: { type: "string", description: "An identifier for the step to be reported on." } },
-                },
-              },
-            },
-          ],
-        };
-        const generated = transformSchemaObject(schema, options);
-        expect(generated).toBe(`OneOf<[{
-  /** @description The ID of an existing resource that exists before the pipeline is run. */
-  id: string;
-}, {
-  /** @description The stage and step to report on. */
-  from: {
-    /** @description An identifier for the stage the step being reported on resides in. */
-    stage?: string;
-    /** @description An identifier for the step to be reported on. */
-    step: string;
-  };
-}]>`);
-      });
-
       test("nullable: true", () => {
         const schema: SchemaObject = { nullable: true, oneOf: [{ type: "integer" }, { type: "string" }] };
         const generated = transformSchemaObject(schema, options);
@@ -538,6 +496,24 @@ describe("Schema Object", () => {
 }`);
       });
 
+      test("discriminator with oneOf and null", () => {
+        const schema: SchemaObject = {
+          oneOf: [{ $ref: 'components["schemas"]["parent"]' }, { type: "null" }],
+        };
+        const generated = transformSchemaObject(schema, {
+          path: options.path,
+          ctx: {
+            ...options.ctx,
+            discriminators: {
+              'components["schemas"]["parent"]': {
+                propertyName: "operation",
+              },
+            },
+          },
+        });
+        expect(generated).toBe(`components["schemas"]["parent"] | null`);
+      });
+
       test("discriminator escape", () => {
         const schema: SchemaObject = {
           type: "object",
@@ -761,8 +737,8 @@ describe("ReferenceObject", () => {
           properties: { string: { type: "string" } },
           "x-extension": true,
         },
-        options,
-      ),
+        options
+      )
     ).toBe("{\n  string?: string;\n}");
   });
 });