Add support for array of types in schema definition

Author: florianreinhart

index.js

@@ -90,7 +90,7 @@ function build (schema, options) {
 
   var dependencies = []
   var dependenciesName = []
-  if (hasAnyOf(schema)) {
+  if (hasAnyOf(schema) || hasArrayOfTypes(schema)) {
     dependencies.push(new Ajv())
     dependenciesName.push('ajv')
   }
@@ -113,6 +113,40 @@ 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 $asNull () {
   return 'null'
 }
@@ -517,6 +551,7 @@ function buildArray (schema, code, name, externalSchema, fullSchema) {
           condition += `Array.isArray(obj${accessor})`
           break
         default:
+          // TODO: item.type can be an array of types.
           throw new Error(`${item.type} unsupported`)
       }
       return {
@@ -622,7 +657,19 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
       } else throw new Error(`${schema} unsupported`)
       break
     default:
-      throw new Error(`${type} unsupported`)
+      if (Array.isArray(type)) {
+        type.forEach((type, index) => {
+          var tempSchema = {type: type}
+          var nestedResult = nested(laterCode, name, key, tempSchema, externalSchema, fullSchema, subKey)
+          code += `
+            ${index === 0 ? 'if' : 'else if'}(ajv.validate(${require('util').inspect(tempSchema, {depth: null})}, obj${accessor}))
+              ${nestedResult.code}
+          `
+          laterCode = nestedResult.laterCode
+        })
+      } else {
+        throw new Error(`${type} unsupported`)
+      }
   }
 
   return {

test/typesArray.test.js

@@ -0,0 +1,185 @@
+'use strict'
+
+const test = require('tap').test
+const build = require('..')
+
+test('simple object with multi-type property', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'simple object with multi-type property',
+    type: 'object',
+    properties: {
+      stringOrNumber: {
+        type: ['string', 'number']
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      stringOrNumber: 'string'
+    })
+    t.is(value, '{"stringOrNumber":"string"}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      stringOrNumber: 42
+    })
+    t.is(value, '{"stringOrNumber":42}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with array of multiple types', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with array of multiple types',
+    type: 'object',
+    properties: {
+      arrayOfStringsAndNumbers: {
+        type: 'array',
+        items: {
+          type: ['string', 'number']
+        }
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      arrayOfStringsAndNumbers: ['string1', 'string2']
+    })
+    t.is(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}')
+  } catch (e) {
+    console.log(e)
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      arrayOfStringsAndNumbers: [42, 7]
+    })
+    t.is(value, '{"arrayOfStringsAndNumbers":[42,7]}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      arrayOfStringsAndNumbers: ['string1', 42, 7, 'string2']
+    })
+    t.is(value, '{"arrayOfStringsAndNumbers":["string1",42,7,"string2"]}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+// TODO: Multiple types inside tuples are currently unsupported
+// test('object with tuple of multiple types', (t) => {
+//   t.plan(2)
+
+//   const schema = {
+//     title: 'object with array of multiple types',
+//     type: 'object',
+//     properties: {
+//       fixedTupleOfStringsAndNumbers: {
+//         type: 'array',
+//         items: [
+//           {
+//             type: 'string'
+//           },
+//           {
+//             type: 'number'
+//           },
+//           {
+//             type: ['string', 'number']
+//           }
+//         ]
+//       }
+//     }
+//   }
+//   const stringify = build(schema)
+
+//   try {
+//     const value = stringify({
+//       fixedTupleOfStringsAndNumbers: ['string1', 42, 7]
+//     })
+//     t.is(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}')
+//   } catch (e) {
+//     console.log(e)
+//     t.fail()
+//   }
+
+//   try {
+//     const value = stringify({
+//       fixedTupleOfStringsAndNumbers: ['string1', 42, 7]
+//     })
+//     t.is(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}')
+//   } catch (e) {
+//     console.log(e)
+//     t.fail()
+//   }
+// })
+
+test('object with anyOf and multiple types', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with anyOf and multiple types',
+    type: 'object',
+    properties: {
+      objectOrBoolean: {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              stringOrNumber: {
+                type: ['string', 'number']
+              }
+            }
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      objectOrBoolean: { stringOrNumber: 'string' }
+    })
+    t.is(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}')
+  } catch (e) {
+    console.log(e)
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      objectOrBoolean: { stringOrNumber: 42 }
+    })
+    t.is(value, '{"objectOrBoolean":{"stringOrNumber":42}}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      objectOrBoolean: true
+    })
+    t.is(value, '{"objectOrBoolean":true}')
+  } catch (e) {
+    t.fail()
+  }
+})