@kravc/schema 2.7.6 → 2.8.0-alpha.1

package/src/Validator.spec.js

@@ -1,355 +0,0 @@
-'use strict'
-
-const { load }         = require('js-yaml')
-const { expect }       = require('chai')
-const { readFileSync } = require('fs')
-const { Schema, Validator } = require('src')
-
-const loadSync = (yamlPath) => {
-  const id     = yamlPath.split('.')[0].split('/').reverse()[0]
-  const source = load(readFileSync(yamlPath))
-
-  return new Schema(source, id)
-}
-
-const SCHEMAS = [
-  'examples/Status.yaml',
-  'examples/Profile.yaml',
-  'examples/Preferences.yaml',
-  'examples/FavoriteItem.yaml'
-].map(path => loadSync(path))
-
-describe('Validator', () => {
-  describe('Validator.constructor(schemas)', () => {
-    it('create validator for schemas', () => {
-      new Validator(SCHEMAS)
-    })
-
-    it('throws error if no schemas provided', () => {
-      expect(
-        () => new Validator()
-      ).to.throw('No schemas provided')
-    })
-
-    it('throws error if referenced schema not found', () => {
-      const entitySchema = new Schema({ name: { $ref: 'MissingSchema' } }, 'Entity')
-
-      expect(
-        () => new Validator([ ...SCHEMAS, entitySchema ])
-      ).to.throw('Schemas validation failed:')
-    })
-  })
-
-  describe('.validate(object, schemaId, shouldNullifyEmptyValues = false, shouldCleanupNulls = true)', () => {
-    it('returns validated, cleaned and normalized object', () => {
-      const validator = new Validator(SCHEMAS)
-
-      const _createdAt = new Date().toISOString()
-
-      const input = {
-        name: 'Oleksandr',
-        toBeRemoved: null,
-        contactDetails: {
-          email: 'a@kra.vc',
-          toBeRemoved: null,
-        },
-        favoriteItems: [
-          {
-            id:         '1',
-            name:       'Student Book',
-            categories: [ 'Education' ],
-            toBeRemoved: null,
-            _createdAt
-          },
-        ],
-        locations: [{
-          name: 'Home',
-          address: {
-            type:         'Primary',
-            zip:          '03119',
-            city:         'Kyiv',
-            addressLine1: 'Melnikova 83-D, 78',
-            _createdAt
-          },
-          _createdAt
-        }],
-        preferences: {
-          height:                180,
-          isNotificationEnabled: true,
-          _createdAt
-        },
-        status: 'Active',
-        _createdAt
-      }
-
-      const validInput = validator.validate(input, 'Profile', false, true)
-
-      expect(validInput.toBeRemoved).to.not.exist
-      expect(validInput.contactDetails.toBeRemoved).to.not.exist
-      expect(validInput.favoriteItems[0].toBeRemoved).to.not.exist
-
-      expect(validInput._createdAt).to.not.exist
-      expect(validInput.preferences._createdAt).to.not.exist
-      expect(validInput.locations[0]._createdAt).to.not.exist
-      expect(validInput.locations[0].address._createdAt).to.not.exist
-      expect(validInput.favoriteItems[0]._createdAt).to.not.exist
-
-      expect(validInput.name).to.eql('Oleksandr')
-      expect(validInput.gender).to.eql('Other')
-      expect(validInput.status).to.eql('Active')
-      expect(validInput.locations[0].name).to.eql('Home')
-      expect(validInput.locations[0].address.country).to.eql('Ukraine')
-      expect(validInput.locations[0].address.zip).to.eql('03119')
-      expect(validInput.locations[0].address.city).to.eql('Kyiv')
-      expect(validInput.locations[0].address.addressLine1).to.eql('Melnikova 83-D, 78',)
-      expect(validInput.locations[0].address.type).to.eql('Primary')
-      expect(validInput.favoriteItems[0].id).to.eql('1')
-      expect(validInput.favoriteItems[0].name).to.eql('Student Book')
-      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.preferences.height).to.eql(180)
-      expect(validInput.preferences.isNotificationEnabled).to.eql(true)
-    })
-
-    it('normalizes object attributes according to property type', () => {
-      const validator = new Validator(SCHEMAS)
-
-      const input = {
-        name: 'Oleksandr',
-        contactDetails: {
-          email: 'a@kra.vc'
-        },
-        preferences: {
-          height:                '180',
-          isNotificationEnabled: 'true'
-        }
-      }
-
-      let validInput
-
-      validInput = validator.validate(input, 'Profile')
-      expect(validInput.preferences.height).to.eql(180)
-      expect(validInput.preferences.isNotificationEnabled).to.eql(true)
-
-      input.preferences.isNotificationEnabled = '1'
-      validInput = validator.validate(input, 'Profile')
-      expect(validInput.preferences.isNotificationEnabled).to.eql(true)
-
-      input.preferences.isNotificationEnabled = '0'
-      validInput = validator.validate(input, 'Profile')
-      expect(validInput.preferences.isNotificationEnabled).to.eql(false)
-
-      input.preferences.isNotificationEnabled = 0
-      validInput = validator.validate(input, 'Profile')
-      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)
-
-      const input = {}
-
-      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')
-
-        expect(error.validationErrors).to.have.lengthOf(2)
-
-        return
-      }
-
-      throw new Error('Validation error is not thrown')
-    })
-
-    it('throws error if schema not found', () => {
-      const validator = new Validator(SCHEMAS)
-
-      expect(
-        () => validator.validate({}, 'Account')
-      ).to.throw('Schema "Account" not found')
-    })
-
-    it('throws error if multiple schemas with same id', async () => {
-      const exampleSchema1 = new Schema({
-        number: { required: true }
-      }, 'Example')
-
-      const exampleSchema2 = new Schema({
-        id: {}
-      }, 'Example')
-
-      expect(() => new Validator([ exampleSchema1, exampleSchema2 ]))
-        .to.throw('Multiple "Example" schemas provided')
-    })
-  })
-
-  describe('.validate(object, schemaId, shouldNullifyEmptyValues = 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, shouldNullifyEmptyValues = 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)
-
-      const input = {}
-
-      const normalizedInput = validator.normalize(input, 'Profile')
-
-      expect(normalizedInput.gender).to.eql('Other')
-      expect(normalizedInput.status).to.eql('Pending')
-    })
-
-    it('throws error if schema not found', () => {
-      const validator = new Validator(SCHEMAS)
-
-      expect(
-        () => validator.normalize({}, 'Account')
-      ).to.throw('Schema "Account" not found')
-    })
-  })
-
-  describe('.schemasMap', () => {
-    it('returns schemas map', () => {
-      const validator = new Validator(SCHEMAS)
-
-      expect(validator.schemasMap).to.exist
-    })
-  })
-
-  describe('.getReferenceIds(schemaId)', () => {
-    it('returns ids of referenced schemas', () => {
-      const validator    = new Validator(SCHEMAS)
-      const referenceIds = validator.getReferenceIds('Profile')
-
-      expect(referenceIds).to.eql([ 'Status', 'FavoriteItem', 'Preferences' ])
-    })
-  })
-})

package/src/helpers/cleanupAttributes.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const { isUndefined } = require('lodash')
-
-const cleanupAttributes = (object, jsonSchema, schemasMap) => {
-  const { id, enum: isEnum } = jsonSchema
-
-  if (isEnum) { return }
-
-
-  for (const fieldName in object) {
-    const property = jsonSchema.properties[fieldName]
-    const isPropertyUndefined = isUndefined(property)
-
-    if (isPropertyUndefined) {
-      delete object[fieldName]
-
-    } else {
-      const { $ref: refSchemaId, properties, type } = property
-
-      const isArray     = type === 'array'
-      const isObject    = type === 'object'
-      const isReference = !isUndefined(refSchemaId)
-
-      if (isReference) {
-        const refJsonSchema = schemasMap[refSchemaId]
-
-        cleanupAttributes(object[fieldName], refJsonSchema, schemasMap)
-
-      } else if (isObject) {
-        const nestedJsonSchema = {
-          id:   `${id}.${fieldName}.properties`,
-          type: 'object',
-          properties
-        }
-
-        cleanupAttributes(object[fieldName], nestedJsonSchema, schemasMap)
-
-      } else if (isArray) {
-        const { items } = property
-        const { $ref: itemRefSchemaId, properties: itemProperties } = items
-
-        const array = object[fieldName]
-        const isItemObject    = !!itemProperties
-        const isItemReference = !!itemRefSchemaId
-
-        let itemJsonSchema
-
-        if (isItemReference) {
-          itemJsonSchema = schemasMap[itemRefSchemaId]
-
-        } else if (isItemObject) {
-          itemJsonSchema = {
-            id:         `${id}.${fieldName}.item`,
-            type:       'object',
-            properties: itemProperties
-          }
-
-        }
-
-        if (itemJsonSchema) {
-          for (const item of array) {
-            cleanupAttributes(item, itemJsonSchema, schemasMap)
-          }
-        }
-      }
-    }
-  }
-}
-
-module.exports = cleanupAttributes

package/src/helpers/cleanupNulls.js

@@ -1,42 +0,0 @@
-'use strict'
-
-const { isArray } = Array
-const { isObject, cloneDeep } = require('lodash')
-
-const cleanupNulls = object => {
-  if (!isObject(object)) {
-    return
-  }
-
-  for (const key in object) {
-    const value = object[key]
-
-    if (isArray(value)) {
-      for (const item of value) {
-        cleanupNulls(item)
-      }
-
-      continue
-    }
-
-    if (isObject(value)) {
-      cleanupNulls(value)
-
-      continue
-    }
-
-    const isNull = value === null
-
-    if (isNull) {
-      delete object[key]
-    }
-  }
-}
-
-module.exports = input => {
-  const object = cloneDeep(input)
-
-  cleanupNulls(object)
-
-  return object
-}

package/src/helpers/getReferenceIds.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const { isUndefined, uniq } = require('lodash')
-const Schema = require('../Schema')
-
-const getReferenceIds = (schema, schemasMap) => {
-  const getSchema = id => schemasMap[id]
-
-  let referenceIds = []
-
-  const { jsonSchema } = schema
-  const { id, enum: isEnum } = jsonSchema
-
-  if (isEnum) { return [] }
-
-  for (const propertyName in jsonSchema.properties) {
-    const property = jsonSchema.properties[propertyName]
-
-    const { $ref: refSchemaId, properties, items } = property
-
-    const isArray     = property.type === 'array'
-    const isObject    = property.type === 'object'
-    const isReference = !isUndefined(refSchemaId)
-
-    if (isReference) {
-      const refJsonSchema      = getSchema(refSchemaId, `${id}.${propertyName}.$ref`)
-      const nestedReferenceIds = getReferenceIds(refJsonSchema, schemasMap)
-
-      referenceIds = [ ...referenceIds, refSchemaId, ...nestedReferenceIds ]
-      continue
-
-    }
-
-    if (isObject) {
-      const nestedSchema       = new Schema(properties, `${id}.${propertyName}.properties`)
-      const nestedReferenceIds = getReferenceIds(nestedSchema, schemasMap)
-
-      referenceIds = [ ...referenceIds, ...nestedReferenceIds ]
-      continue
-    }
-
-    if (!isArray) {
-      continue
-    }
-
-    const itemProperties  = items.properties
-    const itemRefSchemaId = items.$ref
-
-    let itemJsonSchema
-
-    if (itemRefSchemaId) {
-      itemJsonSchema = getSchema(itemRefSchemaId, `${id}.${propertyName}.items.$ref`)
-      const nestedReferenceIds = getReferenceIds(itemJsonSchema, schemasMap)
-
-      referenceIds = [ ...referenceIds, itemRefSchemaId, ...nestedReferenceIds ]
-      continue
-    }
-
-    if (itemProperties) {
-      const itemSchema = new Schema(itemProperties, `${id}.${propertyName}.items.properties`)
-      const itemReferenceIds = getReferenceIds(itemSchema, schemasMap)
-
-      referenceIds = [ ...referenceIds, ...itemReferenceIds ]
-      continue
-    }
-  }
-
-  return uniq(referenceIds)
-}
-
-module.exports = getReferenceIds

package/src/helpers/mapObject.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const { isUndefined } = require('lodash')
-
-const mapObject = (object, jsonSchema, schemasMap, callback) => {
-  const { id, enum: isEnum } = jsonSchema
-
-  if (isEnum) { return }
-
-  for (const propertyName in jsonSchema.properties) {
-    const property = jsonSchema.properties[propertyName]
-
-    callback(propertyName, property, object)
-
-    const { $ref: refSchemaId, properties, items } = property
-
-    const value          = object[propertyName]
-    const isArray        = property.type === 'array'
-    const isObject       = property.type === 'object'
-    const isReference    = !isUndefined(refSchemaId)
-    const isValueDefined = !isUndefined(value)
-
-    if (isValueDefined) {
-      if (isReference) {
-        const refJsonSchema = schemasMap[refSchemaId]
-
-        mapObject(value, refJsonSchema, schemasMap, callback)
-
-      } else if (isObject) {
-        const nestedJsonSchema = {
-          id:   `${id}.${propertyName}.properties`,
-          type: 'object',
-          properties
-        }
-
-        mapObject(value, nestedJsonSchema, schemasMap, callback)
-
-      } else if (isArray) {
-        const itemProperties  = items.properties
-        const itemRefSchemaId = items.$ref
-
-        let itemJsonSchema
-
-        if (itemRefSchemaId) {
-          itemJsonSchema = schemasMap[itemRefSchemaId]
-
-        } else if (itemProperties) {
-          itemJsonSchema = {
-            id:         `${id}.${propertyName}.items.properties`,
-            type:       'object',
-            properties: itemProperties
-          }
-        }
-
-        if (itemJsonSchema) {
-          for (const valueItem of value) {
-            mapObject(valueItem, itemJsonSchema, schemasMap, callback)
-          }
-        }
-      }
-    }
-  }
-}
-
-module.exports = mapObject

package/src/helpers/normalizeAttributes.js

@@ -1,28 +0,0 @@
-'use strict'
-
-const mapObject     = require('./mapObject')
-const normalizeType = require('./normalizeType')
-const { isUndefined } = require('lodash')
-
-const normalizeAttributes = (object, jsonSchema, jsonSchemasMap) => {
-  const callback = (propertyName, propertySchema, object) => {
-    const value = object[propertyName]
-
-    const { type, default: defaultValue } = propertySchema
-
-    const hasDefaultValue = !isUndefined(defaultValue)
-    const isValueDefined  = !isUndefined(value)
-
-    if (hasDefaultValue && !isValueDefined) {
-      object[propertyName] = defaultValue
-    }
-
-    if (type && isValueDefined) {
-      object[propertyName] = normalizeType(type, value)
-    }
-  }
-
-  mapObject(object, jsonSchema, jsonSchemasMap, callback)
-}
-
-module.exports = normalizeAttributes

package/src/helpers/normalizeProperties.js

@@ -1,61 +0,0 @@
-'use strict'
-
-const { isUndefined } = require('lodash')
-
-const normalizeProperties = properties => {
-  const { enum: isEnum } = properties
-
-  if (isEnum) {
-    properties.type = properties.type || 'string'
-    return
-  }
-
-  for (const name in properties) {
-    const property = properties[name]
-
-    const { type: hasType, $ref: isRef, items: hasItems, properties: hasProperties } = property
-
-    if (!isRef) {
-      if (!hasType) {
-        if (hasProperties) {
-          property.type = 'object'
-
-        } else if (hasItems) {
-          property.type = 'array'
-
-        } else {
-          property.type = 'string'
-
-        }
-      }
-
-      const isArray  = property.type === 'array'
-      const isObject = property.type === 'object'
-
-      if (isObject) {
-        if (!hasProperties) {
-          property.properties = {}
-        }
-
-        normalizeProperties(property.properties)
-      }
-
-      if (isArray) {
-        if (hasItems) {
-          const isItemObject = !isUndefined(property.items.properties)
-
-          if (isItemObject) {
-            property.items.type = 'object'
-            normalizeProperties(property.items.properties)
-          }
-
-        } else {
-          property.items = { type: 'string' }
-
-        }
-      }
-    }
-  }
-}
-
-module.exports = normalizeProperties