fix: handle type: "null" in anyOf / oneOf / allOf (#252)

previously `EmptyObject` was erroneously being added to the resulting
type / schema, which would cause a build error in the case of a header
parameter that used this pattern.

Author: mnahkies

packages/openapi-code-generator/src/core/input.ts

@@ -426,6 +426,12 @@ function normalizeSchemaObject(
       }
 
       const properties = normalizeProperties(schemaObject.properties)
+
+      const hasNull =
+        hasATypeNull(schemaObject.allOf) ||
+        hasATypeNull(schemaObject.oneOf) ||
+        hasATypeNull(schemaObject.anyOf)
+
       const allOf = normalizeAllOf(schemaObject.allOf)
       const oneOf = normalizeOneOf(schemaObject.oneOf)
       const anyOf = normalizeAnyOf(schemaObject.anyOf)
@@ -447,7 +453,7 @@ function normalizeSchemaObject(
       return {
         ...base,
         // TODO: HACK
-        nullable: base.nullable || schemaObject.type === "null",
+        nullable: base.nullable || schemaObject.type === "null" || hasNull,
         type: "object",
         allOf,
         oneOf,
@@ -554,11 +560,15 @@ function normalizeSchemaObject(
   }
 
   function normalizeAllOf(allOf: Schema["allOf"] = []): MaybeIRModel[] {
-    return allOf.map(normalizeSchemaObject)
+    return allOf
+      ?.filter((it) => isRef(it) || it.type !== "null")
+      .map(normalizeSchemaObject)
   }
 
   function normalizeOneOf(oneOf: Schema["oneOf"] = []): MaybeIRModel[] {
-    return oneOf.map(normalizeSchemaObject)
+    return oneOf
+      .filter((it) => isRef(it) || it.type !== "null")
+      .map(normalizeSchemaObject)
   }
 
   function normalizeAnyOf(anyOf: Schema["anyOf"] = []): MaybeIRModel[] {
@@ -568,8 +578,16 @@ function normalizeSchemaObject(
         //       anyOf: [ {required: ["bla"]}, {required: ["foo"]} ] in addition to top-level schema, which looks like
         //       it's intended to indicate that at least one of the objects properties must be set (consider it a
         //       Omit<Partial<Thing>, EmptyObject> )
-        return isRef(it) || Boolean(it.type)
+        return isRef(it) || (Boolean(it.type) && it.type !== "null")
       })
       .map(normalizeSchemaObject)
   }
+
+  function hasATypeNull(arr?: (Schema | Reference)[]) {
+    return Boolean(
+      arr?.find((it) => {
+        return !isRef(it) && it.type === "null"
+      }),
+    )
+  }
 }

packages/openapi-code-generator/src/core/openapi-types-normalized.ts

@@ -1,4 +1,3 @@
-import {xInternalPreproccess} from "./openapi-types"
 import type {HttpMethod} from "./utils"
 
 export interface IRRef {
@@ -85,13 +84,18 @@ export interface IRModelArray extends IRModelBase {
   // TODO: contains / maxContains / minContains
 }
 
+export interface IRModelNull extends IRModelBase {
+  type: "null"
+}
+
 export type IRModel =
   | IRModelNumeric
   | IRModelString
   | IRModelBoolean
   | IRModelObject
   | IRModelArray
   | IRModelAny
+  | IRModelNull
 
 export type MaybeIRModel = IRModel | IRRef
 

packages/openapi-code-generator/src/test/unit-test-inputs-3.0.3.yaml

@@ -101,6 +101,10 @@ components:
       anyOf:
         - type: number
         - type: string
+    AnyOfNullableString:
+      anyOf:
+        - type: string
+        - type: "null"
 
     AllOf:
       allOf:

packages/openapi-code-generator/src/test/unit-test-inputs-3.1.0.yaml

@@ -105,6 +105,10 @@ components:
       type:
         - number
         - string
+    AnyOfNullableString:
+      anyOf:
+        - type: string
+        - type: "null"
 
     AllOf:
       allOf:

packages/openapi-code-generator/src/typescript/common/schema-builders/abstract-schema-builder.ts

@@ -320,6 +320,8 @@ export abstract class AbstractSchemaBuilder<
         result = this.config.allowAny ? this.any() : this.unknown()
         break
       }
+      case "null":
+        throw new Error("unreachable - input should normalize this out")
     }
 
     if (model["x-internal-preprocess"]) {

packages/openapi-code-generator/src/typescript/common/schema-builders/zod-schema-builder.spec.ts

@@ -539,6 +539,31 @@ describe.each(testVersions)(
         )
       })
 
+      it("supports nullable string using allOf", async () => {
+        const {code, execute} = await getActualFromModel({
+          type: "object",
+          anyOf: [
+            {type: "string", nullable: false, readOnly: false},
+            {type: "null", nullable: false, readOnly: false},
+          ],
+          allOf: [],
+          oneOf: [],
+          properties: {},
+          additionalProperties: undefined,
+          required: [],
+          nullable: false,
+          readOnly: false,
+        })
+
+        expect(code).toMatchInlineSnapshot('"const x = z.string().nullable()"')
+
+        await expect(execute("a string")).resolves.toBe("a string")
+        await expect(execute(null)).resolves.toBe(null)
+        await expect(execute(123)).rejects.toThrow(
+          "Expected string, received number",
+        )
+      })
+
       it("supports minLength", async () => {
         const {code, execute} = await getActualFromModel({
           ...base,

packages/openapi-code-generator/src/typescript/common/type-builder.spec.ts

@@ -129,6 +129,22 @@ describe.each(testVersions)(
       )
     })
 
+    it("can build a type for a nullable string using anyOf correctly", async () => {
+      const {code, types} = await getActual(
+        "components/schemas/AnyOfNullableString",
+      )
+
+      expect(code).toMatchInlineSnapshot(`
+        "import {t_AnyOfNullableString} from './unit-test.types'
+
+        const x: t_AnyOfNullableString"
+      `)
+
+      expect(types).toMatchInlineSnapshot(
+        '"export type t_AnyOfNullableString = string | null"',
+      )
+    })
+
     it("can build a type for a allOf correctly", async () => {
       const {code, types} = await getActual("components/schemas/AllOf")