@kravc/schema 2.3.1 → 2.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kravc/schema",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "Advanced JSON schema manipulation and validation library.",
   "keywords": [
     "JSON",
@@ -35,7 +35,7 @@
     "lodash.uniq": "^4.5.0",
     "security-context": "^4.0.0",
     "validator": "^13.7.0",
-    "z-schema": "^5.0.2"
+    "z-schema": "^5.0.5"
   },
   "devDependencies": {
     "chai": "^4.3.4",

package/src/Validator.js

@@ -46,9 +46,29 @@ class Validator {
       throw new Error(`Schema "${schemaId}" not found`)
     }
 
-    const result = JSON.parse(JSON.stringify(object))
-    cleanupAttributes(result, jsonSchema, this._jsonSchemasMap)
-    normalizeAttributes(result, jsonSchema, this._jsonSchemasMap)
+    const objectJson = JSON.stringify(object)
+    const result = JSON.parse(objectJson)
+
+    try {
+      // NOTE: Drop attributes from objects that are not defined in schema.
+      //       This is bad for FE developers, as they continue to send some
+      //       trash to endpoints, but good for integrations with third party
+      //       services, e.g. Telegram, when you do not want to define schema
+      //       for the full payload. This method currently fails for cases when
+      //       attribute is defined as object or array in schema, but value is
+      //       a string. In this case validation method below would catch that.
+      cleanupAttributes(result, jsonSchema, this._jsonSchemasMap)
+
+      // NOTE: Normalize method helps to integrate objects built from URLs,
+      //       where types are not defined, e.g. booleans are '1', 'yes' string
+      //       or numbers are '1', '2'... strings.
+      normalizeAttributes(result, jsonSchema, this._jsonSchemasMap)
+
+    } catch (error) {
+      // NOTE: Skip errors in cleanup and normalize attributes methods,
+      //       validation fails for objects with invalid value types.
+
+    }
 
     const isValid = this._engine.validate(result, jsonSchema)
 

package/src/Validator.spec.js

@@ -137,12 +137,50 @@ describe('Validator', () => {
       expect(validInput.preferences.isNotificationEnabled).to.eql(false)
 
       expect(() => {
+        input.preferences.isNotificationEnabled = 'NaN'
+        validInput = validator.validate(input, 'Profile')
+        expect(validInput.preferences.isNotificationEnabled).to.eql('NaN')
+      }).to.throw('"Profile" validation failed')
+
+      expect(() => {
+        input.preferences.isNotificationEnabled = 0
         input.preferences.height = 'NaN'
         validInput = validator.validate(input, 'Profile')
         expect(validInput.preferences.height).to.eql('NaN')
       }).to.throw('"Profile" validation failed')
     })
 
+    it('throws validation error if cleanup or normalize method failed', () => {
+      const validator = new Validator(SCHEMAS)
+
+      const input = {
+        name: 'Oleksandr',
+        contactDetails: {
+          email: 'a@kra.vc'
+        },
+        favoriteItems: 'NOT_ARRAY_BUT_STRING'
+      }
+
+      try {
+        validator.validate(input, 'Profile')
+
+      } catch (validationError) {
+        const error = validationError.toJSON()
+
+        expect(error.object).to.exist
+        expect(error.code).to.eql('ValidationError')
+        expect(error.message).to.eql('"Profile" validation failed')
+        expect(error.schemaId).to.eql('Profile')
+
+        const errorMessage = error.validationErrors[0].message
+        expect(errorMessage).to.eql('Expected type array but found type string')
+
+        return
+      }
+
+      throw new Error('Validation error is not thrown')
+    })
+
     it('throws error if validation failed', () => {
       const validator = new Validator(SCHEMAS)
 

package/src/helpers/normalizeType.js

@@ -1,5 +1,8 @@
 'use strict'
 
+const BOOLEAN_STRING_TRUE_VALUES = ['yes', 'true', '1']
+const BOOLEAN_STRING_FALSE_VALUES = ['no', 'false', '0']
+
 const normalizeType = (type, value) => {
   let normalizedValue = value
 
@@ -22,8 +25,12 @@ const normalizeType = (type, value) => {
       }
 
       if (isStringValue) {
-        const isTrue = value.toLowerCase() === 'true' || value === '1'
-        normalizedValue = isTrue ? true : false
+        const isTrue = BOOLEAN_STRING_TRUE_VALUES.includes(value.toLowerCase())
+        const isFalse = BOOLEAN_STRING_FALSE_VALUES.includes(value.toLowerCase())
+
+        if (isTrue || isFalse) {
+          normalizedValue = isTrue ? true : false
+        }
       }
     }
   }