Fix object and null possible type handling. (#104)

* Fix object and null possible type handling.

Remove ajv for multiple type handling.

* Remove object spreading.

Author: ruiaraujo

bench.js

@@ -11,7 +11,7 @@ const schema = {
       'type': 'string'
     },
     'lastName': {
-      'type': 'string'
+      'type': ['string', 'null']
     },
     'age': {
       'description': 'Age in years',

index.js

@@ -94,7 +94,7 @@ function build (schema, options) {
 
   var dependencies = []
   var dependenciesName = []
-  if (hasAnyOf(schema) || hasArrayOfTypes(schema) || hasShemaSomeIf) {
+  if (hasAnyOf(schema) || hasShemaSomeIf) {
     dependencies.push(new Ajv())
     dependenciesName.push('ajv')
   }
@@ -117,40 +117,6 @@ function hasAnyOf (schema) {
   return false
 }
 
-function hasArrayOfTypes (schema) {
-  if (Array.isArray(schema.type)) { return true }
-  var i
-
-  if (schema.type === 'object') {
-    if (schema.properties) {
-      var propertyKeys = Object.keys(schema.properties)
-      for (i = 0; i < propertyKeys.length; i++) {
-        if (hasArrayOfTypes(schema.properties[propertyKeys[i]])) {
-          return true
-        }
-      }
-    }
-  } else if (schema.type === 'array') {
-    if (Array.isArray(schema.items)) {
-      for (i = 0; i < schema.items.length; i++) {
-        if (hasArrayOfTypes(schema.items[i])) {
-          return true
-        }
-      }
-    } else if (schema.items) {
-      return hasArrayOfTypes(schema.items)
-    }
-  } else if (Array.isArray(schema.anyOf)) {
-    for (i = 0; i < schema.anyOf.length; i++) {
-      if (hasArrayOfTypes(schema.anyOf[i])) {
-        return true
-      }
-    }
-  }
-
-  return false
-}
-
 function hasIf (schema) {
   const str = JSON.stringify(schema)
   return /"if":{/.test(str) && /"then":{/.test(str)
@@ -764,17 +730,29 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
       break
     default:
       if (Array.isArray(type)) {
-        type.forEach((type, index) => {
-          var tempSchema = {type: type}
+        const nullIndex = type.indexOf('null')
+        const sortedTypes = nullIndex !== -1 ? [type[nullIndex]].concat(type.slice(0, nullIndex)).concat(type.slice(nullIndex + 1)) : type
+        sortedTypes.forEach((type, index) => {
+          var tempSchema = Object.assign({}, schema, {type})
           var nestedResult = nested(laterCode, name, key, tempSchema, externalSchema, fullSchema, subKey)
           if (type === 'string') {
             code += `
-              ${index === 0 ? 'if' : 'else if'}(obj${accessor} instanceof Date || ajv.validate(${require('util').inspect(tempSchema, {depth: null})}, obj${accessor}))
+              ${index === 0 ? 'if' : 'else if'}(typeof obj${accessor} === "${type}" || obj${accessor} instanceof Date || obj${accessor} instanceof RegExp)
                 ${nestedResult.code}
             `
+          } else if (type === 'null') {
+            code += `
+              ${index === 0 ? 'if' : 'else if'}(obj${accessor} == null)
+              ${nestedResult.code}
+            `
+          } else if (type === 'array') {
+            code += `
+              ${index === 0 ? 'if' : 'else if'}(Array.isArray(obj${accessor}))
+              ${nestedResult.code}
+            `
           } else {
             code += `
-              ${index === 0 ? 'if' : 'else if'}(ajv.validate(${require('util').inspect(tempSchema, {depth: null})}, obj${accessor}))
+              ${index === 0 ? 'if' : 'else if'}(typeof obj${accessor} === "${type}")
               ${nestedResult.code}
             `
           }

test/typesArray.test.js

@@ -3,56 +3,83 @@
 const test = require('tap').test
 const build = require('..')
 
-test('simple object with multi-type property', (t) => {
-  t.plan(2)
+test('possibly null object with multi-type property', (t) => {
+  t.plan(3)
 
   const schema = {
     title: 'simple object with multi-type property',
     type: 'object',
     properties: {
-      stringOrNumber: {
-        type: ['string', 'number']
+      objectOrNull: {
+        type: ['object', 'null'],
+        properties: {
+          stringOrNumber: {
+            type: ['string', 'number']
+          }
+        }
       }
     }
   }
   const stringify = build(schema)
 
   try {
     const value = stringify({
-      stringOrNumber: 'string'
+      objectOrNull: {
+        stringOrNumber: 'string'
+      }
     })
-    t.is(value, '{"stringOrNumber":"string"}')
+    t.is(value, '{"objectOrNull":{"stringOrNumber":"string"}}')
   } catch (e) {
     t.fail()
   }
 
   try {
     const value = stringify({
-      stringOrNumber: 42
+      objectOrNull: {
+        stringOrNumber: 42
+      }
     })
-    t.is(value, '{"stringOrNumber":42}')
+    t.is(value, '{"objectOrNull":{"stringOrNumber":42}}')
+  } catch (e) {
+    t.fail()
+  }
+  try {
+    const value = stringify({
+      objectOrNull: null
+    })
+    t.is(value, '{"objectOrNull":null}')
   } catch (e) {
     t.fail()
   }
 })
 
-test('object with array of multiple types', (t) => {
-  t.plan(3)
+test('object with possibly null array of multiple types', (t) => {
+  t.plan(5)
 
   const schema = {
     title: 'object with array of multiple types',
     type: 'object',
     properties: {
       arrayOfStringsAndNumbers: {
-        type: 'array',
+        type: ['array', 'null'],
         items: {
-          type: ['string', 'number']
+          type: ['string', 'number', 'null']
         }
       }
     }
   }
   const stringify = build(schema)
 
+  try {
+    const value = stringify({
+      arrayOfStringsAndNumbers: null
+    })
+    t.is(value, '{"arrayOfStringsAndNumbers":null}')
+  } catch (e) {
+    console.log(e)
+    t.fail()
+  }
+
   try {
     const value = stringify({
       arrayOfStringsAndNumbers: ['string1', 'string2']
@@ -80,6 +107,14 @@ test('object with array of multiple types', (t) => {
   } catch (e) {
     t.fail()
   }
+  try {
+    const value = stringify({
+      arrayOfStringsAndNumbers: ['string1', null, 42, 7, 'string2', null]
+    })
+    t.is(value, '{"arrayOfStringsAndNumbers":["string1",null,42,7,"string2",null]}')
+  } catch (e) {
+    t.fail()
+  }
 })
 
 test('object with tuple of multiple types', (t) => {