fix schema.nullable() to support non-strings

packages/kbn-config-schema/src/index.ts

@@ -36,7 +36,6 @@ import {
   MapOfOptions,
   MapOfType,
   MaybeType,
-  NullableType,
   NeverType,
   NumberOptions,
   NumberType,
@@ -102,7 +101,7 @@ function maybe<V>(type: Type<V>): Type<V | undefined> {
 }
 
 function nullable<V>(type: Type<V>): Type<V | null> {
-  return new NullableType(type);
+  return schema.oneOf([type, schema.literal(null)], { defaultValue: () => null });
 }
 
 function object<P extends Props>(props: P, options?: ObjectTypeOptions<P>): ObjectType<P> {

packages/kbn-config-schema/src/types/index.ts

@@ -26,7 +26,6 @@ export { ConditionalType, ConditionalTypeValue } from './conditional_type';
 export { DurationOptions, DurationType } from './duration_type';
 export { LiteralType } from './literal_type';
 export { MaybeType } from './maybe_type';
-export { NullableType } from './nullable_type';
 export { MapOfOptions, MapOfType } from './map_type';
 export { NumberOptions, NumberType } from './number_type';
 export { ObjectType, ObjectTypeOptions, Props, TypeOf } from './object_type';

packages/kbn-config-schema/src/types/nullable_type.test.ts

@@ -19,19 +19,66 @@
 
 import { schema } from '..';
 
-test('returns value if specified', () => {
+test('returns string value when passed string', () => {
   const type = schema.nullable(schema.string());
-  expect(type.validate('test')).toEqual('test');
+  expect(type.validate('test')).toBe('test');
 });
 
-test('returns null if null', () => {
+test('returns number value when passed number', () => {
+  const type = schema.nullable(schema.number());
+  expect(type.validate(42)).toBe(42);
+});
+
+test('returns boolean value when passed boolean', () => {
+  const type = schema.nullable(schema.boolean());
+  expect(type.validate(true)).toBe(true);
+});
+
+test('returns object value when passed object', () => {
+  const type = schema.nullable(
+    schema.object({
+      foo: schema.number(),
+      bar: schema.boolean(),
+      baz: schema.string(),
+    })
+  );
+  const object = {
+    foo: 666,
+    bar: true,
+    baz: 'foo bar baz',
+  };
+
+  expect(type.validate(object)).toEqual(object);
+});
+
+test('returns null if null for string', () => {
   const type = schema.nullable(schema.string());
-  expect(type.validate(null)).toEqual(null);
+  expect(type.validate(null)).toBe(null);
+});
+
+test('returns null if null for number', () => {
+  const type = schema.nullable(schema.number());
+  expect(type.validate(null)).toBe(null);
 });
 
-test('returns null if undefined', () => {
+test('returns null if null for boolean', () => {
+  const type = schema.nullable(schema.boolean());
+  expect(type.validate(null)).toBe(null);
+});
+
+test('returns null if undefined for string', () => {
   const type = schema.nullable(schema.string());
-  expect(type.validate(undefined)).toEqual(null);
+  expect(type.validate(undefined)).toBe(null);
+});
+
+test('returns null if undefined for number', () => {
+  const type = schema.nullable(schema.number());
+  expect(type.validate(undefined)).toBe(null);
+});
+
+test('returns null if undefined for boolean', () => {
+  const type = schema.nullable(schema.boolean());
+  expect(type.validate(undefined)).toBe(null);
 });
 
 test('returns null even if contained type has a default value', () => {
@@ -41,7 +88,7 @@ test('returns null even if contained type has a default value', () => {
     })
   );
 
-  expect(type.validate(undefined)).toEqual(null);
+  expect(type.validate(undefined)).toBe(null);
 });
 
 test('validates contained type', () => {
@@ -56,6 +103,27 @@ test('validates basic type', () => {
   expect(() => type.validate(666)).toThrowErrorMatchingSnapshot();
 });
 
+test('validates type in object', () => {
+  const type = schema.object({
+    foo: schema.nullable(schema.string({ maxLength: 1 })),
+    bar: schema.nullable(schema.boolean()),
+  });
+
+  expect(type.validate({ foo: 'a' })).toEqual({ foo: 'a', bar: null });
+  expect(type.validate({ foo: null })).toEqual({ foo: null, bar: null });
+  expect(type.validate({})).toEqual({ foo: null, bar: null });
+  expect(type.validate({ bar: null })).toEqual({ foo: null, bar: null });
+});
+
+test('validates type errors in object', () => {
+  const type = schema.object({
+    foo: schema.nullable(schema.string({ maxLength: 1 })),
+    bar: schema.nullable(schema.boolean()),
+  });
+
+  expect(() => type.validate({ foo: 'ab' })).toThrowErrorMatchingSnapshot();
+});
+
 test('includes namespace in failure', () => {
   const type = schema.nullable(schema.string({ maxLength: 1 }));