Fixed base class discriminators to only be handled in allOfs

Author: mzronek

packages/openapi-typescript/examples/digital-ocean-api.ts

@@ -19323,7 +19323,7 @@ export interface operations {
          *      */
         requestBody?: {
             content: {
-                "application/json": Omit<components["schemas"]["floating_ip_action_unassign"], "type"> | Omit<components["schemas"]["floating_ip_action_assign"], "type">;
+                "application/json": components["schemas"]["floating_ip_action_unassign"] | components["schemas"]["floating_ip_action_assign"];
             };
         };
         responses: {
@@ -22367,7 +22367,7 @@ export interface operations {
          *      */
         requestBody?: {
             content: {
-                "application/json": Omit<components["schemas"]["reserved_ip_action_unassign"], "type"> | Omit<components["schemas"]["reserved_ip_action_assign"], "type">;
+                "application/json": components["schemas"]["reserved_ip_action_unassign"] | components["schemas"]["reserved_ip_action_assign"];
             };
         };
         responses: {

packages/openapi-typescript/src/lib/utils.ts

@@ -326,7 +326,7 @@ export function scanDiscriminators(
   // (sometimes this mapping is implicit, so it can’t be done until we know
   // about every discriminator in the document)
   walk(schema, (obj, path) => {
-    for (const key of ["oneOf", "anyOf", "allOf"] as const) {
+    for (const key of ["allOf"] as const) {
       if (obj && Array.isArray(obj[key])) {
         for (const item of (obj as any)[key]) {
           if ("$ref" in item) {

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

@@ -138,8 +138,18 @@ export function transformSchemaObjectWithComposition(
    * Object + composition (anyOf/allOf/oneOf) types
    */
 
-  /** Collect oneOf/allOf/anyOf with Omit<> for discriminators */
-  function collectCompositions(
+  /** Collect oneOf/anyOf */
+  function collectUnionCompositions(items: (SchemaObject | ReferenceObject)[]) {
+    const output: ts.TypeNode[] = [];
+    for (const item of items) {
+      output.push(transformSchemaObject(item, options));
+    }
+
+    return output;
+  }
+
+  /** Collect allOf with Omit<> for discriminators */
+  function collectAllOfCompositions(
     items: (SchemaObject | ReferenceObject)[],
     required?: string[],
   ): ts.TypeNode[] {
@@ -184,6 +194,7 @@ export function transformSchemaObjectWithComposition(
           options,
         );
       }
+
       const discriminator =
         ("$ref" in item && options.ctx.discriminators.objects[item.$ref]) ||
         (item as any).discriminator; // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -201,7 +212,7 @@ export function transformSchemaObjectWithComposition(
 
   // core + allOf: intersect
   const coreObjectType = transformSchemaObjectCore(schemaObject, options);
-  const allOfType = collectCompositions(
+  const allOfType = collectAllOfCompositions(
     schemaObject.allOf ?? [],
     schemaObject.required,
   );
@@ -216,21 +227,17 @@ export function transformSchemaObjectWithComposition(
   }
   // anyOf: union
   // (note: this may seem counterintuitive, but as TypeScript’s unions are not true XORs, they mimic behavior closer to anyOf than oneOf)
-  const anyOfType = collectCompositions(
-    schemaObject.anyOf ?? [],
-    schemaObject.required,
-  );
+  const anyOfType = collectUnionCompositions(schemaObject.anyOf ?? []);
   if (anyOfType.length) {
     finalType = tsUnion([...(finalType ? [finalType] : []), ...anyOfType]);
   }
   // oneOf: union (within intersection with other types, if any)
-  const oneOfType = collectCompositions(
+  const oneOfType = collectUnionCompositions(
     schemaObject.oneOf ||
       ("type" in schemaObject &&
         schemaObject.type === "object" &&
         (schemaObject.enum as (SchemaObject | ReferenceObject)[])) ||
       [],
-    schemaObject.required,
   );
   if (oneOfType.length) {
     // note: oneOf is the only type that may include primitives
@@ -408,8 +415,8 @@ function transformSchemaObjectCore(
   // type: object
   const coreObjectType: ts.TypeElement[] = [];
 
-  // discriminatorss: explicit mapping on schema object
-  for (const k of ["oneOf", "allOf", "anyOf"] as const) {
+  // discriminators: explicit mapping on schema object
+  for (const k of ["allOf", "anyOf"] as const) {
     if (!schemaObject[k]) {
       continue;
     }

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

@@ -43,6 +43,38 @@ describe("3.1 discriminators", () => {
                 },
                 allOf: [{ $ref: "#/components/schemas/Pet" }],
               },
+              LizardDog: {
+                allOf: [
+                  { $ref: "#/components/schemas/Dog" },
+                  { $ref: "#/components/schemas/Lizard" },
+                ],
+              },
+              AnimalSighting: {
+                oneOf: [
+                  {
+                    $ref: "#/components/schemas/Cat",
+                  },
+                  {
+                    $ref: "#/components/schemas/Dog",
+                  },
+                  {
+                    $ref: "#/components/schemas/Lizard",
+                  },
+                ],
+              },
+              Beast: {
+                anyOf: [
+                  {
+                    $ref: "#/components/schemas/Cat",
+                  },
+                  {
+                    $ref: "#/components/schemas/Dog",
+                  },
+                  {
+                    $ref: "#/components/schemas/Lizard",
+                  },
+                ],
+              },
             },
           },
         },
@@ -65,6 +97,11 @@ export interface components {
             petType: "Lizard";
             lovesRocks?: boolean;
         } & Omit<components["schemas"]["Pet"], "petType">;
+        LizardDog: {
+            petType: "LizardDog";
+        } & (Omit<components["schemas"]["Dog"], "petType"> & Omit<components["schemas"]["Lizard"], "petType">);
+        AnimalSighting: components["schemas"]["Cat"] | components["schemas"]["Dog"] | components["schemas"]["Lizard"];
+        Beast: components["schemas"]["Cat"] | components["schemas"]["Dog"] | components["schemas"]["Lizard"];
     };
     responses: never;
     parameters: never;

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

@@ -258,20 +258,12 @@ describe("composition", () => {
       "discriminator > oneOf",
       {
         given: {
-          type: "object",
-          required: ["name"],
-          properties: {
-            name: { type: "string" },
-          },
           oneOf: [
             { $ref: "#/components/schemas/Cat" },
             { $ref: "#/components/schemas/Dog" },
           ],
         },
-        want: `{
-    petType: "Pet";
-    name: string;
-} & (Omit<components["schemas"]["Cat"], "petType"> | Omit<components["schemas"]["Dog"], "petType">)`,
+        want: `components["schemas"]["Cat"] | components["schemas"]["Dog"]`,
         options: {
           path: "#/components/schemas/Pet",
           ctx: {
@@ -313,9 +305,7 @@ describe("composition", () => {
         given: {
           oneOf: [{ $ref: "#/components/schemas/parent" }, { type: "null" }],
         },
-        want: `{
-    operation: "schema-object";
-} & (Omit<components["schemas"]["parent"], "operation"> | null)`,
+        want: `components["schemas"]["parent"] | null`,
         options: {
           ...DEFAULT_OPTIONS,
           ctx: {