Improve tests, fix additional bugs

Author: drwpow

packages/openapi-typescript/src/load.ts

@@ -1,4 +1,4 @@
-import type { ComponentsObject, Fetch, GlobalContext, OpenAPI3, OperationObject, ParameterObject, PathItemObject, ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject, Subschema } from "./types.js";
+import type { ComponentsObject, DiscriminatorObject, Fetch, GlobalContext, OpenAPI3, OperationObject, ParameterObject, PathItemObject, ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject, Subschema } from "./types.js";
 import fs from "node:fs";
 import path from "node:path";
 import { Readable } from "node:stream";
@@ -296,7 +296,19 @@ export default async function load(schema: URL | Subschema | Readable, options:
       walk(options.schemas[k].schema, (rawNode, nodePath) => {
         const node = rawNode as unknown as SchemaObject;
         if (!node.discriminator) return;
-        options.discriminators[schemaID === "." ? makeTSIndex(nodePath) : makeTSIndex(["external", k, ...nodePath])] = node.discriminator;
+        const discriminator: DiscriminatorObject = { ...node.discriminator };
+
+        // handle child oneOf types (mapping isn’t explicit from children)
+        const oneOf: string[] = [];
+        if (Array.isArray(node.oneOf)) {
+          for (const child of node.oneOf) {
+            if (!child || typeof child !== "object" || !("$ref" in child)) continue;
+            oneOf.push(child.$ref);
+          }
+        }
+        if (oneOf.length) discriminator.oneOf = oneOf;
+
+        options.discriminators[schemaID === "." ? makeTSIndex(nodePath) : makeTSIndex(["external", k, ...nodePath])] = discriminator;
       });
     }
   }

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

@@ -1,4 +1,4 @@
-import type { GlobalContext, ReferenceObject, SchemaObject } from "../types.js";
+import type { DiscriminatorObject, GlobalContext, ReferenceObject, SchemaObject } from "../types.js";
 import { escObjKey, escStr, getEntries, getSchemaObjectComment, indent, parseRef, tsArrayOf, tsIntersectionOf, tsOmit, tsOneOf, tsOptionalProperty, tsReadonly, tsTupleOf, tsUnionOf, tsWithRequired } from "../utils.js";
 import transformSchemaObjectMap from "./schema-object-map.js";
 
@@ -162,21 +162,24 @@ export function defaultSchemaObjectTransform(schemaObject: SchemaObject | Refere
   // core type: properties + additionalProperties
   const coreType: string[] = [];
 
-  // discriminators
+  // discriminators: explicit mapping on schema object
   for (const k of ["oneOf", "allOf", "anyOf"] as ("oneOf" | "allOf" | "anyOf")[]) {
     if (!(schemaObject as any)[k]) continue;
-    const discriminatorRef: ReferenceObject | undefined = (schemaObject as any)[k].find((t: SchemaObject | ReferenceObject) => "$ref" in t && ctx.discriminators[t.$ref]);
-    if (discriminatorRef) {
-      const discriminator = ctx.discriminators[discriminatorRef.$ref];
-      // get the inferred propertyName value from the last section of the path (as the spec suggests to do)
-      let value = parseRef(path).path.pop()!;
-      // if mapping, and there’s a match, use this rather than the inferred name
-      if (discriminator.mapping) {
-        // 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));
+    const discriminatorRef: ReferenceObject | undefined = (schemaObject as any)[k].find(
+      (t: SchemaObject | ReferenceObject) =>
+        "$ref" in t &&
+        (ctx.discriminators[t.$ref] || // explicit allOf from this node
+          Object.values(ctx.discriminators).find((d) => d.oneOf?.includes(path))), // implicit oneOf from parent
+    );
+    if (discriminatorRef && ctx.discriminators[discriminatorRef.$ref]) {
+      coreType.unshift(indent(getDiscriminatorPropertyName(path, ctx.discriminators[discriminatorRef.$ref]), indentLv + 1));
+      break;
+    }
+  }
+  // discriminators: implicit mapping from parent
+  for (const d of Object.values(ctx.discriminators)) {
+    if (d.oneOf?.includes(path)) {
+      coreType.unshift(indent(getDiscriminatorPropertyName(path, d), indentLv + 1));
       break;
     }
   }
@@ -236,7 +239,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]?.mapping) {
+      if ("$ref" in item && ctx.discriminators[item.$ref]) {
         output.push(tsOmit(itemType, [ctx.discriminators[item.$ref].propertyName]));
         continue;
       }
@@ -274,3 +277,15 @@ export function defaultSchemaObjectTransform(schemaObject: SchemaObject | Refere
   // if no type could be generated, fall back to “empty object” type
   return ctx.emptyObjectsUnknown ? "Record<string, unknown>" : "Record<string, never>";
 }
+
+export function getDiscriminatorPropertyName(path: string, discriminator: DiscriminatorObject): string {
+  // get the inferred propertyName value from the last section of the path (as the spec suggests to do)
+  let value = parseRef(path).path.pop()!;
+  // if mapping, and there’s a match, use this rather than the inferred name
+  if (discriminator.mapping) {
+    // 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!?
+  }
+  return `${escObjKey(discriminator.propertyName)}: ${escStr(value)};`;
+}

packages/openapi-typescript/src/types.ts

@@ -508,6 +508,8 @@ export interface DiscriminatorObject {
   propertyName: string;
   /** An object to hold mappings between payload values and schema names or references. */
   mapping?: Record<string, string>;
+  /** If this exists, then a discriminator type should be added to objects matching this path */
+  oneOf?: string[];
 }
 
 /**