is-my-json-valid - npm Package Compare versions

Comparing version 2.18.0 to 2.19.0

index.d.ts

@@ -1,55 +0,80 @@
-interface NullSchema {
-  type: 'null'
-}
+type AnySchema = NullSchema | BooleanSchema | NullableBooleanSchema | NumberSchema | NullableNumberSchema | StringSchema | NullableStringSchema | AnyEnumSchema | AnyArraySchema | AnyNullableArraySchema | AnyObjectSchema | AnyNullableObjectSchema | AnyAllOptionalObjectSchema | AnyNullableAllOptionalObjectSchema | AnyOneOfSchema
+type StringKeys<T> = (keyof T) & string
 
-interface BooleanSchema {
-  type: 'boolean'
-}
+interface NullSchema { type: 'null' }
 
-interface NumberSchema {
-  type: 'number'
-}
+interface BooleanSchema { type: 'boolean' }
+interface NullableBooleanSchema { type: ('boolean' | 'null')[] }
 
-interface StringSchema {
-  type: 'string'
-}
+interface NumberSchema { type: 'number' }
+interface NullableNumberSchema { type: ('number' | 'null')[] }
 
-type LeafSchema = NullSchema | BooleanSchema | NumberSchema | StringSchema
+interface StringSchema { type: 'string' }
+interface NullableStringSchema { type: ('string' | 'null')[] }
 
-interface ArraySchema<T extends LeafSchema | ArraySchema<LeafSchema | ObjectSchema<ObjectProps, any>> | ObjectSchema<ObjectProps, any>> {
-  type: 'array'
-  items: T
+interface AnyEnumSchema extends EnumSchema<any> {}
+interface EnumSchema<Enum> { enum: Enum[] }
+
+interface AnyArraySchema extends ArraySchema<AnySchema> {}
+interface ArraySchema<ItemSchema extends AnySchema> { type: 'array', items: ItemSchema }
+
+interface AnyNullableArraySchema extends NullableArraySchema<AnySchema> {}
+interface NullableArraySchema<ItemSchema extends AnySchema> { type: ('array' | 'null')[], items: ItemSchema }
+
+interface AnyObjectSchema extends ObjectSchema<Record<string, AnySchema>, string> {}
+interface ObjectSchema<Properties extends Record<string, AnySchema>, Required extends StringKeys<Properties>> {
+  additionalProperties?: boolean
+  type: 'object'
+  properties: Properties
+  required: Required[]
 }
 
-type ObjectProps = { [K in string]: LeafSchema | ArraySchema<LeafSchema | ArraySchema<LeafSchema | ObjectSchema<ObjectProps, any>> | ObjectSchema<ObjectProps, any>> | ObjectSchema<ObjectProps, any> }
+interface AnyNullableObjectSchema extends NullableObjectSchema<Record<string, AnySchema>, string> {}
+interface NullableObjectSchema<Properties extends Record<string, AnySchema>, Required extends StringKeys<Properties>> {
+  additionalProperties?: boolean
+  type: ('object' | 'null')[]
+  properties: Properties
+  required: Required[]
+}
 
-interface ObjectSchema<T extends ObjectProps, R extends keyof T> {
+interface AnyAllOptionalObjectSchema extends AllOptionalObjectSchema<Record<string, AnySchema>> {}
+interface AllOptionalObjectSchema<Properties extends Record<string, AnySchema>> {
   additionalProperties?: boolean
   type: 'object'
-  properties: T
-  required: R[]
+  properties: Properties
 }
 
-interface ExtractedSchemaArray<T> extends Array<ExtractSchemaType<T>> {}
+interface AnyNullableAllOptionalObjectSchema extends NullableAllOptionalObjectSchema<Record<string, AnySchema>> {}
+interface NullableAllOptionalObjectSchema<Properties extends Record<string, AnySchema>> {
+  additionalProperties?: boolean
+  type: ('object' | 'null')[]
+  properties: Properties
+}
 
-declare type ExtractedSchemaObject<T, R> = {
-  [K in keyof T]: (K extends R ? ExtractSchemaType<T[K]> : ExtractSchemaType<T[K]> | undefined)
+interface AnyOneOfSchema { oneOf: AnySchema[] }
+
+interface ArrayFromSchema<ItemSchema extends AnySchema> extends Array<TypeFromSchema<ItemSchema>> {}
+
+type ObjectFromSchema<Properties extends Record<string, AnySchema>, Required extends StringKeys<Properties>> = {
+  [Key in keyof Properties]: (Key extends Required ? TypeFromSchema<Properties[Key]> : TypeFromSchema<Properties[Key]> | undefined)
 }
 
-declare type ExtractSchemaType<Type> = (
-    Type extends NullSchema ? null
-    : Type extends BooleanSchema ? boolean
-    : Type extends NumberSchema ? number
-    : Type extends StringSchema ? string
-    : Type extends ArraySchema<infer T> ? ExtractedSchemaArray<T>
-    : Type extends ObjectSchema<infer T, infer R> ? ExtractedSchemaObject<T, R>
-    : never
+type TypeFromSchema<Schema extends AnySchema> = (
+    Schema extends EnumSchema<infer Enum> ? Enum
+  : Schema extends NullSchema ? null
+  : Schema extends BooleanSchema ? boolean
+  : Schema extends NullableBooleanSchema ? (boolean | null)
+  : Schema extends NumberSchema ? number
+  : Schema extends NullableNumberSchema ? (number | null)
+  : Schema extends StringSchema ? string
+  : Schema extends NullableStringSchema ? (string | null)
+  : Schema extends ArraySchema<infer ItemSchema> ? ArrayFromSchema<ItemSchema>
+  : Schema extends NullableArraySchema<infer ItemSchema> ? (ArrayFromSchema<ItemSchema> | null)
+  : Schema extends ObjectSchema<infer Properties, infer Required> ? ObjectFromSchema<Properties, Required>
+  : Schema extends NullableObjectSchema<infer Properties, infer Required> ? (ObjectFromSchema<Properties, Required> | null)
+  : Schema extends AllOptionalObjectSchema<infer Properties> ? ObjectFromSchema<Properties, never>
+  : Schema extends NullableAllOptionalObjectSchema<infer Properties> ? (ObjectFromSchema<Properties, never> | null)
+  : never
 )
 
-declare type GenericSchema = (
-  { type: 'string' | 'number' | 'boolean' | 'null' } |
-  { type: 'array', items: GenericSchema } |
-  { type: 'object', properties: ObjectProps }
-)
-
 declare namespace factory {
@@ -64,11 +89,40 @@ interface ValidationError {
 
-declare function createValidator<T extends ObjectProps, R extends keyof T> (schema: ObjectSchema<T, R>, options?: any): ((input: unknown, options?: any) => input is { [K in keyof T]: (K extends R ? ExtractSchemaType<T[K]> : ExtractSchemaType<T[K]> | undefined) }) & { errors: factory.ValidationError[] }
-declare function createValidator<T extends GenericSchema> (schema: T, options?: any): ((input: unknown, options?: any) => input is ExtractSchemaType<T>) & { errors: factory.ValidationError[] }
+interface Validator<Schema extends AnySchema, Output = TypeFromSchema<Schema>> {
+  (input: unknown, options?: any): input is Output
+  errors: factory.ValidationError[]
+  toJSON(): Schema
+}
 
-declare function createFilter<T extends ObjectProps, R extends keyof T> (schema: ObjectSchema<T, R>, options?: any): ((input: { [K in keyof T]: (K extends R ? ExtractSchemaType<T[K]> : ExtractSchemaType<T[K]> | undefined) }, options?: any) => { [K in keyof T]: (K extends R ? ExtractSchemaType<T[K]> : ExtractSchemaType<T[K]> | undefined) })
-declare function createFilter<T extends GenericSchema> (schema: T, options?: any): ((input: ExtractSchemaType<T>, options?: any) => ExtractSchemaType<T>)
+interface Filter<Schema extends AnySchema, Output = TypeFromSchema<Schema>> {
+  (input: Output, options?: any): Output
+}
 
-declare type Factory = (typeof createValidator) & { filter: typeof createFilter }
+interface Factory {
+  /* One of object schema */
+              <Properties1 extends Record<string, AnySchema>, Required1 extends StringKeys<Properties1>, Properties2 extends Record<string, AnySchema>, Required2 extends StringKeys<Properties2>> (schema: { oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>] }, options?: any): Validator<{ oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>] }, ObjectFromSchema<Properties1, Required1> | ObjectFromSchema<Properties2, Required2>>
+  createFilter<Properties1 extends Record<string, AnySchema>, Required1 extends StringKeys<Properties1>, Properties2 extends Record<string, AnySchema>, Required2 extends StringKeys<Properties2>> (schema: { oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>] }, options?: any):    Filter<{ oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>] }, ObjectFromSchema<Properties1, Required1> | ObjectFromSchema<Properties2, Required2>>
+              <Properties1 extends Record<string, AnySchema>, Required1 extends StringKeys<Properties1>, Properties2 extends Record<string, AnySchema>, Required2 extends StringKeys<Properties2>, Properties3 extends Record<string, AnySchema>, Required3 extends StringKeys<Properties3>> (schema: { oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>] }, options?: any): Validator<{ oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>] }, ObjectFromSchema<Properties1, Required1> | ObjectFromSchema<Properties2, Required2> | ObjectFromSchema<Properties3, Required3>>
+  createFilter<Properties1 extends Record<string, AnySchema>, Required1 extends StringKeys<Properties1>, Properties2 extends Record<string, AnySchema>, Required2 extends StringKeys<Properties2>, Properties3 extends Record<string, AnySchema>, Required3 extends StringKeys<Properties3>> (schema: { oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>] }, options?: any):    Filter<{ oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>] }, ObjectFromSchema<Properties1, Required1> | ObjectFromSchema<Properties2, Required2> | ObjectFromSchema<Properties3, Required3>>
+              <Properties1 extends Record<string, AnySchema>, Required1 extends StringKeys<Properties1>, Properties2 extends Record<string, AnySchema>, Required2 extends StringKeys<Properties2>, Properties3 extends Record<string, AnySchema>, Required3 extends StringKeys<Properties3>, Properties4 extends Record<string, AnySchema>, Required4 extends StringKeys<Properties4>> (schema: { oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>, ObjectSchema<Properties4, Required4>] }, options?: any): Validator<{ oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>, ObjectSchema<Properties4, Required4>] }, ObjectFromSchema<Properties1, Required1> | ObjectFromSchema<Properties2, Required2> | ObjectFromSchema<Properties3, Required3> | ObjectFromSchema<Properties4, Required4>>
+  createFilter<Properties1 extends Record<string, AnySchema>, Required1 extends StringKeys<Properties1>, Properties2 extends Record<string, AnySchema>, Required2 extends StringKeys<Properties2>, Properties3 extends Record<string, AnySchema>, Required3 extends StringKeys<Properties3>, Properties4 extends Record<string, AnySchema>, Required4 extends StringKeys<Properties4>> (schema: { oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>, ObjectSchema<Properties4, Required4>] }, options?: any):    Filter<{ oneOf: [ObjectSchema<Properties1, Required1>, ObjectSchema<Properties2, Required2>, ObjectSchema<Properties3, Required3>, ObjectSchema<Properties4, Required4>] }, ObjectFromSchema<Properties1, Required1> | ObjectFromSchema<Properties2, Required2> | ObjectFromSchema<Properties3, Required3> | ObjectFromSchema<Properties4, Required4>>
+
+  /* One of plain schema */
+              <Schema1 extends AnySchema, Schema2 extends AnySchema> (schema: { oneOf: [Schema1, Schema2] }, options?: any): Validator<{ oneOf: [Schema1, Schema2] }, TypeFromSchema<Schema1> | TypeFromSchema<Schema2>>
+  createFilter<Schema1 extends AnySchema, Schema2 extends AnySchema> (schema: { oneOf: [Schema1, Schema2] }, options?: any):    Filter<{ oneOf: [Schema1, Schema2] }, TypeFromSchema<Schema1> | TypeFromSchema<Schema2>>
+              <Schema1 extends AnySchema, Schema2 extends AnySchema, Schema3 extends AnySchema> (schema: { oneOf: [Schema1, Schema2, Schema3] }, options?: any): Validator<{ oneOf: [Schema1, Schema2, Schema3] }, TypeFromSchema<Schema1> | TypeFromSchema<Schema2> | TypeFromSchema<Schema3>>
+  createFilter<Schema1 extends AnySchema, Schema2 extends AnySchema, Schema3 extends AnySchema> (schema: { oneOf: [Schema1, Schema2, Schema3] }, options?: any):    Filter<{ oneOf: [Schema1, Schema2, Schema3] }, TypeFromSchema<Schema1> | TypeFromSchema<Schema2> | TypeFromSchema<Schema3>>
+              <Schema1 extends AnySchema, Schema2 extends AnySchema, Schema3 extends AnySchema, Schema4 extends AnySchema> (schema: { oneOf: [Schema1, Schema2, Schema3, Schema4] }, options?: any): Validator<{ oneOf: [Schema1, Schema2, Schema3, Schema4] }, TypeFromSchema<Schema1> | TypeFromSchema<Schema2> | TypeFromSchema<Schema3> | TypeFromSchema<Schema4>>
+  createFilter<Schema1 extends AnySchema, Schema2 extends AnySchema, Schema3 extends AnySchema, Schema4 extends AnySchema> (schema: { oneOf: [Schema1, Schema2, Schema3, Schema4] }, options?: any):    Filter<{ oneOf: [Schema1, Schema2, Schema3, Schema4] }, TypeFromSchema<Schema1> | TypeFromSchema<Schema2> | TypeFromSchema<Schema3> | TypeFromSchema<Schema4>>
+
+  /* Object schema */
+              <Properties extends Record<string, AnySchema>, Required extends StringKeys<Properties>> (schema: ObjectSchema<Properties, Required>, options?: any): Validator<ObjectSchema<Properties, Required>>
+  createFilter<Properties extends Record<string, AnySchema>, Required extends StringKeys<Properties>> (schema: ObjectSchema<Properties, Required>, options?: any):    Filter<ObjectSchema<Properties, Required>>
+
+  /* Plain schema */
+              <Schema extends AnySchema> (schema: Schema, options?: any): Validator<Schema>
+  createFilter<Schema extends AnySchema> (schema: Schema, options?: any):    Filter<Schema>
+}
+
 declare const factory: Factory
 
 export = factory

package.json

 {
   "name": "is-my-json-valid",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "description": "A JSONSchema validator that uses code generation to be extremely fast",
@@ -5,0 +5,0 @@ "main": "index.js",

test/typings.ts

@@ -12,2 +12,3 @@ import createValidator = require('../')
 const nullValidator = createValidator({ type: 'null' })
+assertType<{ type: 'null' }>(nullValidator.toJSON())
 
@@ -26,2 +27,3 @@ if (nullValidator(input)) {
 const numberValidator = createValidator({ type: 'number' })
+assertType<{ type: 'number' }>(numberValidator.toJSON())
 
@@ -33,2 +35,3 @@ if (numberValidator(input)) {
 const stringValidator = createValidator({ type: 'string' })
+assertType<{ type: 'string' }>(stringValidator.toJSON())
 
@@ -52,5 +55,4 @@ if (stringValidator(input)) {
   assertType<string>(input.name)
-  assertType<number | undefined>(input.age)
-  input.age === undefined
-  input.age === 1
+  if (typeof input.age !== 'undefined') assertType<number>(input.age)
+  if (typeof input.age !== 'number') assertType<undefined>(input.age)
 }
@@ -143,3 +145,4 @@
   assertType<{ first: string | undefined, last: string }>(input.name)
-  assertType<string | undefined>(input.name.first)
+  if (typeof input.name.first !== 'undefined') assertType<string>(input.name.first)
+  if (typeof input.name.first !== 'string') assertType<undefined>(input.name.first)
   assertType<string>(input.name.last)
@@ -152,1 +155,262 @@
 }
+
+const booleanValidator = createValidator({
+  enum: [true, false]
+})
+
+if (booleanValidator(input)) {
+  assertType<boolean>(input)
+}
+
+const specificValuesValidator = createValidator({
+  enum: [
+    true as true,
+    1000 as 1000,
+    'XX' as 'XX'
+  ]
+})
+
+if (specificValuesValidator(input)) {
+  if (input !== true && input !== 1000) assertType<'XX'>(input)
+  if (input !== 1000 && input !== 'XX') assertType<true>(input)
+  if (input !== 'XX' && input !== true) assertType<1000>(input)
+}
+
+const metricValidator = createValidator({
+  type: 'object',
+  properties: {
+    name: { type: 'string', enum: ['page-view' as 'page-view'] },
+    page: { type: 'string', minLength: 0 }
+  },
+  required: [
+    'name',
+    'page'
+  ]
+})
+
+if (metricValidator(input)) {
+  assertType<'page-view'>(input.name)
+  assertType<string>(input.page)
+}
+
+const noRequiredFieldsValidator = createValidator({
+  type: 'object',
+  properties: {
+    a: { type: 'string' },
+    b: { type: 'string' },
+    c: { type: 'string' }
+  }
+})
+
+if (noRequiredFieldsValidator(input)) {
+  if (typeof input.a !== 'string') assertType<undefined>(input.a)
+  if (typeof input.b !== 'string') assertType<undefined>(input.b)
+  if (typeof input.c !== 'string') assertType<undefined>(input.c)
+  if (typeof input.a !== 'undefined') assertType<string>(input.a)
+  if (typeof input.b !== 'undefined') assertType<string>(input.b)
+  if (typeof input.c !== 'undefined') assertType<string>(input.c)
+}
+
+const signupValidator = createValidator({
+  type: 'object',
+  properties: {
+    email: {
+      type: 'string'
+    },
+    paymentInformation: {
+      type: 'object',
+      properties: {
+        plan: { type: 'string' },
+        token: { type: 'string' }
+      },
+      required: [
+        'plan' as 'plan',
+        'token' as 'token'
+      ]
+    }
+  },
+  required: [
+    'paymentInformation'
+  ]
+})
+
+if (signupValidator(input)) {
+  if (typeof input.email !== 'string') assertType<undefined>(input.email)
+  if (typeof input.email !== 'undefined') assertType<string>(input.email)
+  assertType<string>(input.paymentInformation.plan)
+  assertType<string>(input.paymentInformation.token)
+}
+
+const animalValidator = createValidator({
+  oneOf: [
+    {
+      type: 'object',
+      properties: {
+        type: { enum: ['cat' as 'cat'] },
+        name: { type: 'string' }
+      },
+      required: [
+        'type',
+        'name'
+      ]
+    },
+    {
+      type: 'object',
+      properties: {
+        type: { enum: ['dog' as 'dog'] },
+        name: { type: 'string' }
+      },
+      required: [
+        'type',
+        'name'
+      ]
+    }
+  ]
+})
+
+if (animalValidator(input)) {
+  if (input.type !== 'cat') assertType<'dog'>(input.type)
+  if (input.type !== 'dog') assertType<'cat'>(input.type)
+  assertType<string>(input.name)
+}
+
+const shapeValidator = createValidator({
+  oneOf: [
+    { type: 'object', properties: { kind: { enum: ['triangle' as 'triangle'] } }, required: ['kind'] },
+    { type: 'object', properties: { kind: { enum: ['rectangle' as 'rectangle'] } }, required: ['kind'] },
+    { type: 'object', properties: { kind: { enum: ['circle' as 'circle'] } }, required: ['kind'] },
+  ]
+})
+
+if (shapeValidator(input)) {
+  if (input.kind !== 'triangle' && input.kind !== 'rectangle') assertType<'circle'>(input.kind)
+  if (input.kind !== 'rectangle' && input.kind !== 'circle') assertType<'triangle'>(input.kind)
+  if (input.kind !== 'circle' && input.kind !== 'triangle') assertType<'rectangle'>(input.kind)
+}
+
+const foobar = createValidator({
+  oneOf: [
+    { type: 'object', properties: { a: { type: 'string' } }, required: ['a'] },
+    { type: 'object', properties: { b: { type: 'number' } }, required: ['b'] },
+    { type: 'object', properties: { c: { type: 'boolean' } }, required: ['c'] },
+    { type: 'object', properties: { d: { type: 'null' } }, required: ['d'] },
+  ]
+})
+
+if (foobar(input)) {
+  if ('a' in input) assertType<string>(input.a)
+  if ('b' in input) assertType<number>(input.b)
+  if ('c' in input) assertType<boolean>(input.c)
+  if ('d' in input) assertType<null>(input.d)
+}
+
+const stringOrNullValidator = createValidator({
+  oneOf: [
+    { type: 'string' },
+    { type: 'null' }
+  ]
+})
+
+if (stringOrNullValidator(input)) {
+  if (typeof input !== 'object') assertType<string>(input)
+  if (typeof input !== 'string') assertType<null>(input)
+}
+
+const primitiveValidator = createValidator({
+  oneOf: [
+    { type: 'string' },
+    { type: 'number' },
+    { type: 'boolean' }
+  ]
+})
+
+if (primitiveValidator(input)) {
+  if (typeof input !== 'string' && typeof input !== 'number') assertType<boolean>(input)
+  if (typeof input !== 'number' && typeof input !== 'boolean') assertType<string>(input)
+  if (typeof input !== 'boolean' && typeof input !== 'string') assertType<number>(input)
+}
+
+const overengineeredColorValidator = createValidator({
+  oneOf: [
+    { enum: ['red' as 'red', 'pink' as 'pink'] },
+    { enum: ['green' as 'green', 'olive' as 'olive'] },
+    { enum: ['blue' as 'blue', 'teal' as 'teal'] },
+    { enum: ['yellow' as 'yellow', 'cream' as 'cream'] }
+  ]
+})
+
+if (overengineeredColorValidator(input)) {
+  if (input !== 'red' && input !== 'pink' && input !== 'green' && input !== 'olive' && input !== 'blue' && input !== 'teal' && input !== 'yellow') assertType<'cream'>(input)
+  if (input !== 'pink' && input !== 'green' && input !== 'olive' && input !== 'blue' && input !== 'teal' && input !== 'yellow' && input !== 'cream') assertType<'red'>(input)
+  if (input !== 'green' && input !== 'olive' && input !== 'blue' && input !== 'teal' && input !== 'yellow' && input !== 'cream' && input !== 'red') assertType<'pink'>(input)
+  if (input !== 'olive' && input !== 'blue' && input !== 'teal' && input !== 'yellow' && input !== 'cream' && input !== 'red' && input !== 'pink') assertType<'green'>(input)
+  if (input !== 'blue' && input !== 'teal' && input !== 'yellow' && input !== 'cream' && input !== 'red' && input !== 'pink' && input !== 'green') assertType<'olive'>(input)
+  if (input !== 'teal' && input !== 'yellow' && input !== 'cream' && input !== 'red' && input !== 'pink' && input !== 'green' && input !== 'olive') assertType<'blue'>(input)
+  if (input !== 'yellow' && input !== 'cream' && input !== 'red' && input !== 'pink' && input !== 'green' && input !== 'olive' && input !== 'blue') assertType<'teal'>(input)
+  if (input !== 'cream' && input !== 'red' && input !== 'pink' && input !== 'green' && input !== 'olive' && input !== 'blue' && input !== 'teal') assertType<'yellow'>(input)
+}
+
+const nullableStringValidator = createValidator({
+  type: ['string', 'null']
+})
+
+if (nullableStringValidator(input)) {
+  if (typeof input !== 'object') assertType<string>(input)
+  if (typeof input !== 'string') assertType<null>(input)
+}
+
+const nullableNameValidator = createValidator({
+  type: 'object',
+  properties: {
+    name: { type: ['string', 'null'] }
+  },
+  required: [
+    'name'
+  ]
+})
+
+if (nullableNameValidator(input)) {
+  if (typeof input.name !== 'object') assertType<string>(input.name)
+  if (typeof input.name !== 'string') assertType<null>(input.name)
+}
+
+const nullableInventoryValidator = createValidator({
+  type: 'object',
+  properties: {
+    inventory: {
+      type: ['array', 'null'],
+      items: { type: 'string' }
+    }
+  },
+  required: [
+    'inventory'
+  ]
+})
+
+if (nullableInventoryValidator(input)) {
+  if (input.inventory === null) assertType<null>(input.inventory)
+  if (input.inventory !== null) assertType<string[]>(input.inventory)
+}
+
+const nullableParentValidator = createValidator({
+  type: 'object',
+  properties: {
+    parent: {
+      type: ['object', 'null'],
+      properties: {
+        name: { type: 'string' }
+      },
+      required: [
+        'name' as 'name'
+      ]
+    }
+  },
+  required: [
+    'parent'
+  ]
+})
+
+if (nullableParentValidator(input)) {
+  if (input.parent === null) assertType<null>(input.parent)
+  if (input.parent !== null) assertType<string>(input.parent.name)
+}

No alert changes

Improved metrics

Total package byte prevSize

137210

increased by13.59%

Lines of code

4056

increased by7.79%

No dependency changes