fix(enum-values): enumValues with nested union types

Author: darkbasic

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

@@ -134,8 +134,8 @@ function isParameterObject(obj: OapiRefResolved | undefined): obj is ParameterOb
   return Boolean(obj && !isOasRef(obj) && obj.in);
 }
 
-function addIndexedAccess(node: ts.TypeReferenceNode | ts.IndexedAccessTypeNode, ...segments: readonly string[]) {
-  return segments.reduce((acc, segment) => {
+function addIndexedAccess(node: ts.TypeNode, ...segments: readonly string[]) {
+  return segments.reduce<ts.TypeNode>((acc, segment) => {
     return ts.factory.createIndexedAccessTypeNode(
       acc,
       ts.factory.createLiteralTypeNode(
@@ -147,6 +147,31 @@ function addIndexedAccess(node: ts.TypeReferenceNode | ts.IndexedAccessTypeNode,
   }, node);
 }
 
+/**
+ * Wrap a type with Extract<T, { propertyName: unknown }> to narrow a union type
+ * before accessing a property that only exists on some variants.
+ */
+function wrapWithExtract(type: ts.TypeNode, propertyName: string): ts.TypeNode {
+  return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Extract"), [
+    type,
+    ts.factory.createTypeLiteralNode([
+      ts.factory.createPropertySignature(
+        /* modifiers     */ undefined,
+        /* name          */ ts.factory.createIdentifier(propertyName),
+        /* questionToken */ undefined,
+        /* type          */ ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+      ),
+    ]),
+  ]);
+}
+
+export interface OapiRefOptions {
+  /** Whether to wrap with FlattenedDeepRequired<> (default: false) */
+  deep?: boolean;
+  /** Array of property names to wrap with Extract<> when accessing */
+  extractProperties?: string[];
+}
+
 /**
  * Convert OpenAPI ref into TS indexed access node (ex: `components["schemas"]["Foo"]`)
  * `path` is a JSON Pointer to a location within an OpenAPI document.
@@ -163,14 +188,18 @@ function addIndexedAccess(node: ts.TypeReferenceNode | ts.IndexedAccessTypeNode,
  *       them according to their type; path, query, header, etc… so in these cases we
  *       must check the parameter definition to determine the how to index into
  *       the openapi-typescript type.
+ *   * Union variant properties (oneOf/anyOf)
+ *       When accessing properties that may only exist on some variants of a union type,
+ *       we use Extract<> to narrow the type before each property access.
  **/
-export function oapiRef(path: string, resolved?: OapiRefResolved, deep = false): ts.TypeNode {
+export function oapiRef(path: string, resolved?: OapiRefResolved, options: OapiRefOptions = {}): ts.TypeNode {
   const { pointer } = parseRef(path);
   if (pointer.length === 0) {
     throw new Error(`Error parsing $ref: ${path}. Is this a valid $ref?`);
   }
 
   const parametersObject = isParameterObject(resolved);
+  const extractSet = new Set(options.extractProperties ?? []);
 
   // Initial segments are handled in a fixed , then remaining segments are treated
   // according to heuristics based on the initial segments
@@ -180,12 +209,14 @@ export function oapiRef(path: string, resolved?: OapiRefResolved, deep = false):
 
   const leadingType = addIndexedAccess(
     ts.factory.createTypeReferenceNode(
-      ts.factory.createIdentifier(deep ? `FlattenedDeepRequired<${String(initialSegment)}>` : String(initialSegment)),
+      ts.factory.createIdentifier(
+        options.deep ? `FlattenedDeepRequired<${String(initialSegment)}>` : String(initialSegment),
+      ),
     ),
     ...leadingSegments,
   );
 
-  return restSegments.reduce<ts.TypeReferenceNode | ts.IndexedAccessTypeNode>((acc, segment, index, original) => {
+  return restSegments.reduce<ts.TypeNode>((acc, segment, index, original) => {
     // Skip `properties` items when in the middle of the pointer
     // See: https://github.com/openapi-ts/openapi-typescript/issues/1742
     if (segment === "properties") {
@@ -196,6 +227,14 @@ export function oapiRef(path: string, resolved?: OapiRefResolved, deep = false):
       return addIndexedAccess(acc, resolved.in, resolved.name);
     }
 
+    // If this segment is in the extractProperties list,
+    // wrap the current type with Extract<T, { segment: unknown }> before accessing.
+    // This narrows union types to variants that have this property.
+    if (extractSet.has(segment)) {
+      const narrowedType = wrapWithExtract(acc, segment);
+      return addIndexedAccess(narrowedType, segment);
+    }
+
     return addIndexedAccess(acc, segment);
   }, leadingType);
 }

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

@@ -149,6 +149,14 @@ export function transformSchemaObjectWithComposition(
       // build a ref path for the type that ignores union indices (anyOf/oneOf) so
       // type references remain stable even when names include union positions
       const cleanedPointer: string[] = [];
+      // Track ALL properties after a oneOf/anyOf that need Extract<> narrowing.
+      // We apply Extract<> before EVERY property access after a union index because:
+      // - When the property exists on ALL variants, Extract<> is a no-op (returns same type)
+      // - When the property only exists on SOME variants, it correctly narrows the union
+      // - When both variants have same property name but different inner schemas,
+      //   we still narrow at each level to handle nested unions correctly
+      // This robust approach handles both simple and complex union structures.
+      const extractProperties: string[] = [];
       for (let i = 0; i < parsed.pointer.length; i++) {
         // Example: #/paths/analytics/data/get/responses/400/content/application/json/anyOf/0/message
         const segment = parsed.pointer[i];
@@ -157,6 +165,16 @@ export function transformSchemaObjectWithComposition(
           if (/^\d+$/.test(next)) {
             // If we encounter something like "anyOf/0", we want to skip that part of the path
             i++;
+            // Collect ALL remaining segments after the union index.
+            // Each one will be wrapped with Extract<> to safely narrow the type
+            // at each level, handling both top-level and nested union variants.
+            const remainingSegments = parsed.pointer.slice(i + 1);
+            for (const seg of remainingSegments) {
+              // Skip union keywords and indices, only add actual property names
+              if (seg !== "anyOf" && seg !== "oneOf" && !/^\d+$/.test(seg)) {
+                extractProperties.push(seg);
+              }
+            }
             continue;
           }
         }
@@ -169,10 +187,10 @@ export function transformSchemaObjectWithComposition(
         // If fromAdditionalProperties is true we are dealing with a record type and we should append [string] to the generated type
         fromAdditionalProperties
           ? ts.factory.createIndexedAccessTypeNode(
-              oapiRef(cleanedRefPath, undefined, true),
+              oapiRef(cleanedRefPath, undefined, { deep: true, extractProperties }),
               ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("string")),
             )
-          : oapiRef(cleanedRefPath, undefined, true),
+          : oapiRef(cleanedRefPath, undefined, { deep: true, extractProperties }),
         schemaObject.enum as (string | number)[],
         {
           export: true,