Refactor nullable handling to always use anyOf

Author: jpkleemans

README.md

@@ -37,7 +37,7 @@ npm install json-schema-kit
   "properties": {
     "name": { "type": "string" },
     "price": { "type": "number", "description": "Price in dollars" },
-    "discount": { "type": ["number", "null"] },
+    "discount": { "anyOf": [{ "type": "number" }, { "type": "null" }] },
     "tags": { "type": "array", "items": { "type": "string" } },
     "dimensions": {
       "type": "object",

src/index.ts

@@ -1,4 +1,4 @@
-import type { Schema, StringSchema, NumberSchema, IntegerSchema, BooleanSchema, ObjectSchema, ArraySchema, AnyOfSchema, RefSchema, AnyOfable } from './types'
+import type { Schema, StringSchema, NumberSchema, IntegerSchema, BooleanSchema, ObjectSchema, ArraySchema, AnyOfSchema, RefSchema } from './types'
 
 export function string(properties: Partial<StringSchema> = {}): StringSchema {
   return {
@@ -52,23 +52,14 @@ export function $ref(id: string): RefSchema {
   }
 }
 
-export function anyOf(subschemas: AnyOfable[]): AnyOfSchema {
+export function anyOf(subschemas: Schema[]): AnyOfSchema {
   return {
     anyOf: subschemas,
   }
 }
 
-// If schema doesn't have a `type` property, it will be converted to an AnyOfSchema
-export type NullableSchema<T> = T extends { type: any } ? T : AnyOfSchema
-
-export function nullable<T extends Schema>(schema: T): NullableSchema<T> {
-  if ('type' in schema) {
-    return { ...schema, type: [schema.type, 'null'] } as NullableSchema<T>
-  }
-
-  if ('anyOf' in schema) {
-    return anyOf([...schema.anyOf, { type: 'null' }]) as NullableSchema<T>
-  }
-
-  return anyOf([schema, { type: 'null' }]) as NullableSchema<T>
+export function nullable(schema: Schema): AnyOfSchema {
+  return 'anyOf' in schema
+    ? anyOf([...schema.anyOf, { type: 'null' }]) // "Extend" existing anyOf with null
+    : anyOf([schema, { type: 'null' }]) // Wrap schema in anyOf with null option
 }

src/types.ts

@@ -8,13 +8,13 @@ export type BaseSchema<T> = {
 }
 
 export type StringSchema = BaseSchema<string> & {
-  type: 'string' | ['string', 'null']
+  type: 'string'
   pattern?: string
   format?: string
 }
 
 export type NumberSchema = BaseSchema<number> & {
-  type: 'number' | ['number', 'null']
+  type: 'number'
   multipleOf?: number
   maximum?: number
   exclusiveMaximum?: number
@@ -23,23 +23,23 @@ export type NumberSchema = BaseSchema<number> & {
 }
 
 export type IntegerSchema = Omit<NumberSchema, 'type'> & {
-  type: 'integer' | ['integer', 'null']
+  type: 'integer'
 }
 
 export type BooleanSchema = BaseSchema<boolean> & {
-  type: 'boolean' | ['boolean', 'null']
+  type: 'boolean'
 }
 
 export type ObjectSchema = BaseSchema<Record<string, any>> & {
-  type: 'object' | ['object', 'null']
+  type: 'object'
   properties: Record<string, Schema>
   required: string[]
   additionalProperties: boolean
   $defs?: Record<string, Schema>
 }
 
 export type ArraySchema = BaseSchema<any[]> & {
-  type: 'array' | ['array', 'null']
+  type: 'array'
   items: Schema
   minItems?: number
   maxItems?: number
@@ -53,7 +53,6 @@ export type RefSchema = {
   $ref: string
 }
 
-export type AnyOfable = ObjectSchema | RefSchema | NullSchema
 export type AnyOfSchema = {
-  anyOf: AnyOfable[]
+  anyOf: Schema[]
 }

tests/index.test.ts

@@ -352,47 +352,50 @@ describe('JSON Schema Kit', () => {
     it('should make string nullable', () => {
       const result = nullable(string())
       expect(result).toEqual({
-        type: ['string', 'null'],
+        anyOf: [{ type: 'string' }, { type: 'null' }],
       })
     })
 
     it('should make number nullable', () => {
       const result = nullable(number({ minimum: 0 }))
       expect(result).toEqual({
-        type: ['number', 'null'],
-        minimum: 0,
+        anyOf: [{ type: 'number', minimum: 0 }, { type: 'null' }],
       })
     })
 
     it('should make integer nullable', () => {
       const result = nullable(integer())
       expect(result).toEqual({
-        type: ['integer', 'null'],
+        anyOf: [{ type: 'integer' }, { type: 'null' }],
       })
     })
 
     it('should make boolean nullable', () => {
       const result = nullable(boolean())
       expect(result).toEqual({
-        type: ['boolean', 'null'],
+        anyOf: [{ type: 'boolean' }, { type: 'null' }],
       })
     })
 
     it('should make object nullable', () => {
       const result = nullable(object({ name: string() }))
       expect(result).toEqual({
-        type: ['object', 'null'],
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-        additionalProperties: false,
+        anyOf: [
+          {
+            type: 'object',
+            properties: { name: { type: 'string' } },
+            required: ['name'],
+            additionalProperties: false,
+          },
+          { type: 'null' },
+        ],
       })
     })
 
     it('should make array nullable', () => {
       const result = nullable(array(string()))
       expect(result).toEqual({
-        type: ['array', 'null'],
-        items: { type: 'string' },
+        anyOf: [{ type: 'array', items: { type: 'string' } }, { type: 'null' }],
       })
     })
 
@@ -445,7 +448,7 @@ describe('JSON Schema Kit', () => {
         properties: {
           name: { type: 'string' },
           price: { type: 'number', description: 'Price in dollars' },
-          discount: { type: ['number', 'null'] },
+          discount: { anyOf: [{ type: 'number' }, { type: 'null' }] },
           tags: { type: 'array', items: { type: 'string' } },
           dimensions: {
             type: 'object',