@kravc/schema 2.3.4 → 2.5.0

package/examples/Profile.yaml

@@ -1,5 +1,6 @@
 name:
   required: true
+  minLength: 3
 
 # NOTE: Referenced enum:
 status:
@@ -20,12 +21,18 @@ contactDetails:
 
   properties:
     email:
-      type:     string
+      type:     'string'
+      format:   'email'
       required: true
 
+    secondaryEmail:
+      type:   'string'
+      format: 'email'
+
     mobileNumber:
       type:    string
-      default: '+380504112171'
+      pattern: '^[0-9]{1,20}$'
+      default: '380504112171'
 
 # NOTE: Array of nested objects:
 locations:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kravc/schema",
-  "version": "2.3.4",
+  "version": "2.5.0",
   "description": "Advanced JSON schema manipulation and validation library.",
   "keywords": [
     "JSON",
@@ -32,10 +32,11 @@
     "lodash.isundefined": "^3.0.1",
     "lodash.keyby": "^4.6.0",
     "lodash.pick": "^4.4.0",
+    "lodash.set": "^4.3.2",
     "lodash.uniq": "^4.5.0",
     "security-context": "^4.0.0",
     "validator": "^13.9.0",
-    "z-schema": "^5.0.5"
+    "z-schema": "^6.0.1"
   },
   "devDependencies": {
     "chai": "^4.3.7",

package/src/Validator.js

@@ -6,6 +6,7 @@ const ZSchema             = require('z-schema')
 const getReferenceIds     = require('./helpers/getReferenceIds')
 const ValidationError     = require('./ValidationError')
 const cleanupAttributes   = require('./helpers/cleanupAttributes')
+const nullifyEmptyValues  = require('./helpers/nullifyEmptyValues')
 const normalizeAttributes = require('./helpers/normalizeAttributes')
 
 class Validator {
@@ -25,7 +26,10 @@ class Validator {
       }
     }
 
-    this._engine = new ZSchema({ ignoreUnknownFormats: true })
+    this._engine = new ZSchema({
+      reportPathAsArray: true,
+      ignoreUnknownFormats: true,
+    })
 
     const jsonSchemas = schemas.map(({ jsonSchema }) => jsonSchema)
     const isValid     = this._engine.validateSchema(jsonSchemas)
@@ -39,7 +43,7 @@ class Validator {
     this._jsonSchemasMap = keyBy(jsonSchemas, 'id')
   }
 
-  validate(object, schemaId) {
+  validate(object, schemaId, shouldCleanupNullValues = false) {
     const jsonSchema = this._jsonSchemasMap[schemaId]
 
     if (!jsonSchema) {
@@ -72,12 +76,25 @@ class Validator {
 
     const isValid = this._engine.validate(result, jsonSchema)
 
-    if (!isValid) {
-      const validationErrors = this._engine.getLastErrors()
+    if (isValid) {
+      return result
+    }
+
+    let validationErrors = this._engine.getLastErrors()
+
+    if (!shouldCleanupNullValues) {
       throw new ValidationError(schemaId, result, validationErrors)
     }
 
-    return result
+    const [ updatedResult, updatedValidationErrors ] = nullifyEmptyValues(result, validationErrors)
+
+    const hasValidationErrors = updatedValidationErrors.length > 0
+
+    if (hasValidationErrors) {
+      throw new ValidationError(schemaId, result, updatedValidationErrors)
+    }
+
+    return updatedResult
   }
 
   normalize(object, schemaId) {

package/src/Validator.spec.js

@@ -40,7 +40,7 @@ describe('Validator', () => {
     })
   })
 
-  describe('.validate(object, schemaId)', () => {
+  describe('.validate(object, schemaId, shouldCleanupNullValues = false)', () => {
     it('returns validated, cleaned and normalized object', () => {
       const validator = new Validator(SCHEMAS)
 
@@ -99,7 +99,7 @@ describe('Validator', () => {
       expect(validInput.favoriteItems[0].categories).to.deep.eql([ 'Education' ])
       expect(validInput.favoriteItems[0].status).to.eql('Pending')
       expect(validInput.contactDetails.email).to.eql('a@kra.vc')
-      expect(validInput.contactDetails.mobileNumber).to.eql('+380504112171')
+      expect(validInput.contactDetails.mobileNumber).to.eql('380504112171')
       expect(validInput.preferences.height).to.eql(180)
       expect(validInput.preferences.isNotificationEnabled).to.eql(true)
     })
@@ -227,6 +227,84 @@ describe('Validator', () => {
     })
   })
 
+  describe('.validate(object, schemaId, shouldCleanupNullValues = false)', () => {
+    it('throws validation error for attributes not matching format or pattern', () => {
+      const validator = new Validator(SCHEMAS)
+
+      const input = {
+        name: 'Oleksandr',
+        gender: '',
+        contactDetails: {
+          email: 'a@kra.vc',
+          secondaryEmail: '',
+          mobileNumber: '',
+        },
+      }
+
+      expect(
+        () => validator.validate(input, 'Profile')
+      ).to.throw('"Profile" validation failed')
+    })
+  })
+
+  describe('.validate(object, schemaId, shouldCleanupNullValues = true)', () => {
+    it('returns input with cleaned up null values for not required attributes', () => {
+      const validator = new Validator(SCHEMAS)
+
+      const input = {
+        name: 'Oleksandr',
+        gender: '', // ENUM
+        contactDetails: {
+          email: 'a@kra.vc',
+          mobileNumber: '', // PATTERN
+          secondaryEmail: '', // FORMAT
+        },
+      }
+
+      const validInput = validator.validate(input, 'Profile', true)
+
+      expect(validInput.gender).to.eql(null)
+      expect(validInput.contactDetails.mobileNumber).to.eql(null)
+      expect(validInput.contactDetails.secondaryEmail).to.eql(null)
+    })
+
+    it('throws validation errors for other attributes', () => {
+      const validator = new Validator(SCHEMAS)
+
+      const input = {
+        name: '', // code: MIN_LENGTH
+        gender: 'NONE', // code: ENUM_MISMATCH
+        contactDetails: {
+          email: 'a@kra.vc',
+          mobileNumber: 'abc', // code: PATTERN
+          secondaryEmail: '',
+        },
+        preferences: {
+          age: 'a' // code: INVALID_TYPE
+        },
+      }
+
+      try {
+        validator.validate(input, 'Profile', true)
+
+      } catch (validationError) {
+        const error = validationError.toJSON()
+
+        expect(error.message).to.eql('"Profile" validation failed')
+        expect(error.validationErrors).to.have.lengthOf(4)
+
+        expect(error.validationErrors[0].code).to.eql('INVALID_TYPE')
+        expect(error.validationErrors[1].code).to.eql('PATTERN')
+        expect(error.validationErrors[2].code).to.eql('ENUM_MISMATCH')
+        expect(error.validationErrors[3].code).to.eql('MIN_LENGTH')
+
+        return
+      }
+
+      throw new Error('Validation error is not thrown')
+    })
+  })
+
   describe('.normalize(object, schemaId)', () => {
     it('returns normalized object clone', () => {
       const validator = new Validator(SCHEMAS)

package/src/helpers/normalizeRequired.js

@@ -10,6 +10,7 @@ const normalizeRequired = jsonSchema => {
     const property = properties[name]
 
     if (property.required) {
+      property['x-required'] = true
       required.push(name)
     }
 

package/src/helpers/nullifyEmptyValues.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const get = require('lodash.get')
+const set = require('lodash.set')
+const { schemaSymbol, jsonSymbol } = require('z-schema')
+
+const FORMAT_ERROR_CODES = [
+  'PATTERN',
+  'ENUM_MISMATCH',
+  'INVALID_FORMAT'
+]
+
+const EMPTY_VALUES = [
+  '',
+]
+
+const nullifyEmptyValues = (object, validationErrors) => {
+  const objectJson = JSON.stringify(object)
+  const result = JSON.parse(objectJson)
+
+  const otherValidationErrors = []
+
+  for (const error of validationErrors) {
+    const { code, path } = error
+
+    const isAttributeRequired = error[schemaSymbol]['x-required'] === true
+    const isFormatError = FORMAT_ERROR_CODES.includes(code)
+
+    if (isAttributeRequired) {
+      otherValidationErrors.push(error)
+      continue
+    }
+
+    if (!isFormatError) {
+      otherValidationErrors.push(error)
+      continue
+    }
+
+    const json = error[jsonSymbol]
+    const value = get(json, path)
+
+    const isEmptyValue = EMPTY_VALUES.includes(value)
+
+    if (!isEmptyValue) {
+      otherValidationErrors.push(error)
+      continue
+    }
+
+    set(result, path, null)
+  }
+
+  return [ result, otherValidationErrors ]
+}
+
+module.exports = nullifyEmptyValues