feat: add required check for object key not in properties (#226)

* feat: add required check for object key not in properties

* perf: remove split, creates the required list of array fields at build time

* refactor: remove message fail. Add string interpolation

Author: davidebianchi

index.js

@@ -631,6 +631,8 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
     schema = refFinder(schema.$ref, fullSchema, externalSchema)
   }
 
+  var required = schema.required
+
   Object.keys(schema.properties || {}).forEach((key, i, a) => {
     if (schema.properties[key].$ref) {
       // if the schema object is deep in the tree, we must resolve the ref in the parent scope
@@ -709,12 +711,14 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
 
     var defaultValue = schema.properties[key].default
     if (defaultValue !== undefined) {
+      required = filterRequired(schema.required, key)
       code += `
       } else {
         ${addComma}
         json += '${asString}:${sanitizeKey(JSON.stringify(defaultValue).replace(/\\/g, '\\\\'))}'
       `
     } else if (schema.required && schema.required.indexOf(key) !== -1) {
+      required = filterRequired(schema.required, key)
       code += `
       } else {
         throw new Error('${sanitized} is required!')
@@ -731,9 +735,33 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
       `
     }
   })
+
+  if (required && required.length > 0) {
+    code += 'var required = ['
+    for (var i = 0; i < required.length; i++) {
+      if (i > 0) {
+        code += ','
+      }
+      code += `${$asString(required[i]).replace(/\\/g, '\\\\')}`
+    }
+    code += ']'
+    code += `
+      for (var i = 0; i < required.length; i++) {
+        if (obj[required[i]] === undefined) throw new Error(required[i] + ' is required!')
+      }
+    `
+  }
+
   return { code: code, laterCode: laterCode }
 }
 
+function filterRequired (required, key) {
+  if (!required) {
+    return required
+  }
+  return required.filter(k => k !== key)
+}
+
 function buildCodeWithAllOfs (schema, code, laterCode, name, externalSchema, fullSchema) {
   if (schema.allOf) {
     schema.allOf.forEach((ss) => {

test/allof.test.js

@@ -135,7 +135,7 @@ test('object with nested allOfs', (t) => {
     allOf: [
       {
         required: [
-          'id'
+          'id1'
         ],
         type: 'object',
         properties: {

test/ref.test.js

@@ -820,7 +820,7 @@ test('ref external to relative definition', (t) => {
 
   const schema = {
     type: 'object',
-    required: ['foo'],
+    required: ['fooParent'],
     properties: {
       fooParent: { $ref: 'relative:to:local' }
     }

test/required.test.js

@@ -41,6 +41,181 @@ test('object with required field', (t) => {
   }
 })
 
+test('object with required field not in properties schema', (t) => {
+  t.plan(4)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'str is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'str is required!')
+    t.pass()
+  }
+})
+
+test('object with required field not in properties schema with additional properties true', (t) => {
+  t.plan(4)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'str is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'str is required!')
+    t.pass()
+  }
+})
+
+test('object with multiple required field not in properties schema', (t) => {
+  t.plan(6)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['num', 'key1', 'key2']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'num is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'key1 is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42,
+      key1: 'some'
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'key2 is required!')
+    t.pass()
+  }
+})
+
+test('object with required bool', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['bool']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, 'bool is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      bool: false
+    })
+    t.pass()
+  } catch (e) {
+    t.fail(e.message)
+  }
+})
+
+test('required nullable', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: ['integer']
+      }
+    },
+    additionalProperties: true,
+    required: ['null']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({
+      null: null
+    })
+    t.pass()
+  } catch (e) {
+    t.fail(e.message)
+  }
+})
+
 test('required numbers', (t) => {
   t.plan(3)