feat: support enum with null to make nullable (#2034)

packages/parsers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/docs-parsers",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "repository": {
     "type": "git",
     "url": "https://github.com/fern-api/fern-platform.git",

packages/parsers/src/openapi/3.1/schemas/MixedSchemaConverter.node.ts

@@ -6,6 +6,7 @@ import {
   BaseOpenApiV3_1ConverterNodeWithExample,
 } from "../../BaseOpenApiV3_1Converter.node";
 import { maybeSingleValueToArray } from "../../utils/maybeSingleValueToArray";
+import { wrapNullable } from "../../utils/wrapNullable";
 import { SchemaConverterNode } from "./SchemaConverter.node";
 
 export declare namespace MixedSchemaConverterNode {
@@ -87,14 +88,7 @@ export class MixedSchemaConverterNode extends BaseOpenApiV3_1ConverterNodeWithEx
     }));
 
     return this.nullable
-      ? unions.map((union) => ({
-          type: "alias" as const,
-          value: {
-            type: "nullable" as const,
-            default: union.variants[0],
-            shape: union,
-          },
-        }))
+      ? unions.map(wrapNullable).filter(isNonNullish)
       : unions;
   }
 

packages/parsers/src/openapi/3.1/schemas/OneOfConverter.node.ts

@@ -7,6 +7,7 @@ import {
 } from "../../BaseOpenApiV3_1Converter.node";
 import { resolveSchemaReference } from "../../utils/3.1/resolveSchemaReference";
 import { maybeSingleValueToArray } from "../../utils/maybeSingleValueToArray";
+import { wrapNullable } from "../../utils/wrapNullable";
 import { SchemaConverterNode } from "./SchemaConverter.node";
 
 export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
@@ -16,6 +17,7 @@ export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
   | FernRegistry.api.latest.TypeShape[]
 > {
   isUnionOfObjects: boolean | undefined;
+  isNullable: boolean | undefined;
   discriminated: boolean | undefined;
   discriminant: string | undefined;
   discriminatedMapping: Record<string, SchemaConverterNode> | undefined;
@@ -36,18 +38,25 @@ export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
           resolveSchemaReference(schema, this.context.document)?.type ===
           "object"
       );
+      this.isNullable = (this.input.oneOf ?? this.input.anyOf)?.some(
+        (schema) =>
+          resolveSchemaReference(schema, this.context.document)?.type === "null"
+      );
       if (this.input.discriminator == null) {
         this.discriminated = false;
-        this.undiscriminatedMapping = (
-          this.input.oneOf ?? this.input.anyOf
-        )?.map((schema) => {
-          return new SchemaConverterNode({
-            input: schema,
-            context: this.context,
-            accessPath: this.accessPath,
-            pathId: this.pathId,
-          });
-        });
+        this.undiscriminatedMapping = (this.input.oneOf ?? this.input.anyOf)
+          ?.map((schema) => {
+            return resolveSchemaReference(schema, this.context.document)
+              ?.type !== "null"
+              ? new SchemaConverterNode({
+                  input: schema,
+                  context: this.context,
+                  accessPath: this.accessPath,
+                  pathId: this.pathId,
+                })
+              : undefined;
+          })
+          .filter(isNonNullish);
       } else {
         const maybeMapping = this.input.discriminator.mapping;
         if (maybeMapping != null) {
@@ -88,9 +97,12 @@ export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
     | FernRegistry.api.latest.TypeShape[]
     | undefined {
     if (!this.isUnionOfObjects && !this.discriminated) {
-      return this.undiscriminatedMapping
+      const convertedNodes = this.undiscriminatedMapping
         ?.flatMap((node) => node.convert())
         .filter(isNonNullish);
+      return this.isNullable && convertedNodes != null
+        ? convertedNodes.map(wrapNullable).filter(isNonNullish)
+        : convertedNodes;
     }
 
     if (
@@ -104,12 +116,12 @@ export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
     ) {
       return undefined;
     }
-    return this.discriminated &&
+    const union =
+      this.discriminated &&
       this.discriminant != null &&
       this.discriminatedMapping != null
-      ? [
-          {
-            type: "discriminatedUnion",
+        ? {
+            type: "discriminatedUnion" as const,
             discriminant: FernRegistry.PropertyKey(this.discriminant),
             variants: Object.entries(this.discriminatedMapping)
               .flatMap(([key, node]) => {
@@ -131,12 +143,10 @@ export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
                   .filter(isNonNullish);
               })
               .filter(isNonNullish),
-          },
-        ]
-      : this.undiscriminatedMapping != null
-        ? [
-            {
-              type: "undiscriminatedUnion",
+          }
+        : this.undiscriminatedMapping != null
+          ? {
+              type: "undiscriminatedUnion" as const,
               variants: this.undiscriminatedMapping
                 .flatMap((node) => {
                   const convertedShapes = maybeSingleValueToArray(
@@ -158,9 +168,10 @@ export class OneOfConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
                     .filter(isNonNullish);
                 })
                 .filter(isNonNullish),
-            },
-          ]
-        : undefined;
+            }
+          : undefined;
+    const wrappedUnion = this.isNullable ? wrapNullable(union) : union;
+    return wrappedUnion != null ? [wrappedUnion] : undefined;
   }
 
   example(): Record<string, unknown> | undefined {

packages/parsers/src/openapi/3.1/schemas/SchemaConverter.node.ts

@@ -1,3 +1,4 @@
+import { isNonNullish } from "@fern-api/ui-core-utils";
 import { OpenAPIV3_1 } from "openapi-types";
 import { UnreachableCaseError } from "ts-essentials";
 import { FernRegistry } from "../../../client/generated";
@@ -6,6 +7,7 @@ import {
   BaseOpenApiV3_1ConverterNodeWithExample,
 } from "../../BaseOpenApiV3_1Converter.node";
 import { maybeSingleValueToArray } from "../../utils/maybeSingleValueToArray";
+import { wrapNullable } from "../../utils/wrapNullable";
 import { AvailabilityConverterNode } from "../extensions/AvailabilityConverter.node";
 import { isArraySchema } from "../guards/isArraySchema";
 import { isBooleanSchema } from "../guards/isBooleanSchema";
@@ -29,6 +31,7 @@ import { IntegerConverterNode } from "./primitives/IntegerConverter.node";
 import { NullConverterNode } from "./primitives/NullConverter.node";
 import { NumberConverterNode } from "./primitives/NumberConverter.node";
 import { StringConverterNode } from "./primitives/StringConverter.node";
+import { UnknownConverterNode } from "./primitives/UnknownConverter.node";
 import { ReferenceConverterNode } from "./ReferenceConverter.node";
 
 export type PrimitiveType =
@@ -220,6 +223,12 @@ export class SchemaConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample
     }
 
     if (this.typeShapeNode == null) {
+      this.typeShapeNode = new UnknownConverterNode({
+        input: this.input,
+        context: this.context,
+        accessPath: this.accessPath,
+        pathId: this.pathId,
+      });
       this.context.errors.error({
         message: "Expected type declaration. Received: null",
         path: this.accessPath,
@@ -232,21 +241,12 @@ export class SchemaConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample
     | FernRegistry.api.latest.TypeShape[]
     | undefined {
     const maybeShapes = this.typeShapeNode?.convert();
-    const mappedShapes = maybeSingleValueToArray(maybeShapes)?.map((shape) =>
-      this.nullable
-        ? {
-            type: "alias" as const,
-            value: {
-              type: "nullable" as const,
-              shape,
-            },
-          }
-        : shape
-    );
-
     if (maybeShapes == null) {
       return undefined;
     }
+    const mappedShapes = maybeSingleValueToArray(maybeShapes)
+      ?.map((shape) => (this.nullable ? wrapNullable(shape) : shape))
+      .filter(isNonNullish);
 
     return Array.isArray(maybeShapes) && maybeShapes.length > 1
       ? mappedShapes

packages/parsers/src/openapi/3.1/schemas/__test__/ArrayConverter.node.test.ts

@@ -91,7 +91,21 @@ describe("ArrayConverterNode", () => {
         message: "Expected type declaration. Received: null",
         path: ["test", "items"],
       });
-      expect(converted).toBeUndefined();
+      expect(converted).toEqual([
+        {
+          type: "alias",
+          value: {
+            type: "list",
+            itemShape: {
+              type: "alias",
+              value: {
+                type: "unknown",
+                displayName: undefined,
+              },
+            },
+          },
+        },
+      ]);
     });
   });
 });

packages/parsers/src/openapi/3.1/schemas/__test__/SchemaConverter.node.test.ts

@@ -201,7 +201,13 @@ describe("SchemaConverterNode", () => {
         accessPath: [],
         pathId: "test",
       });
-      expect(node.convert()).toBeUndefined();
+      expect(node.convert()).toEqual({
+        type: "alias",
+        value: {
+          type: "unknown",
+          displayName: undefined,
+        },
+      });
     });
   });
 });

packages/parsers/src/openapi/3.1/schemas/primitives/NullConverter.node.ts

@@ -4,6 +4,7 @@ import {
   BaseOpenApiV3_1ConverterNodeConstructorArgs,
   BaseOpenApiV3_1ConverterNodeWithExample,
 } from "../../../BaseOpenApiV3_1Converter.node";
+import { wrapNullable } from "../../../utils/wrapNullable";
 import { SchemaConverterNode } from "../SchemaConverter.node";
 
 export declare namespace NullConverterNode {
@@ -13,9 +14,7 @@ export declare namespace NullConverterNode {
 
   export interface Output extends FernRegistry.api.latest.TypeShape.Alias {
     type: "alias";
-    value:
-      | FernRegistry.api.latest.TypeReference.Nullable
-      | FernRegistry.api.latest.TypeReference.Unknown;
+    value: FernRegistry.api.latest.TypeReference.Nullable;
   }
 }
 
@@ -38,19 +37,13 @@ export class NullConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
   }
 
   convert(): NullConverterNode.Output | undefined {
-    return {
+    return wrapNullable({
       type: "alias",
       value: {
-        type: "nullable",
-        shape: {
-          type: "alias",
-          value: {
-            type: "unknown",
-            displayName: this.displayName,
-          },
-        },
+        type: "unknown",
+        displayName: this.displayName,
       },
-    };
+    });
   }
 
   example(): null {

packages/parsers/src/openapi/3.1/schemas/primitives/UnknownConverter.node.ts

@@ -0,0 +1,45 @@
+import { noop } from "ts-essentials";
+import { FernRegistry } from "../../../../client/generated";
+import {
+  BaseOpenApiV3_1ConverterNodeConstructorArgs,
+  BaseOpenApiV3_1ConverterNodeWithExample,
+} from "../../../BaseOpenApiV3_1Converter.node";
+import { SchemaConverterNode } from "../SchemaConverter.node";
+
+export declare namespace UnknownConverterNode {
+  export interface Output extends FernRegistry.api.latest.TypeShape.Alias {
+    type: "alias";
+    value: FernRegistry.api.latest.TypeReference.Unknown;
+  }
+}
+
+export class UnknownConverterNode extends BaseOpenApiV3_1ConverterNodeWithExample<
+  unknown,
+  UnknownConverterNode.Output
+> {
+  displayName: string | undefined;
+  shape: SchemaConverterNode | undefined;
+
+  constructor(args: BaseOpenApiV3_1ConverterNodeConstructorArgs<unknown>) {
+    super(args);
+    this.safeParse();
+  }
+
+  parse(): void {
+    noop();
+  }
+
+  convert(): UnknownConverterNode.Output | undefined {
+    return {
+      type: "alias",
+      value: {
+        type: "unknown",
+        displayName: undefined,
+      },
+    };
+  }
+
+  example(): undefined {
+    return undefined;
+  }
+}