@kravc/schema 2.7.6 → 2.8.0-alpha.0

package/src/Schema.spec.js

@@ -1,172 +0,0 @@
-'use strict'
-
-const { load }         = require('js-yaml')
-const { Schema }       = require('src')
-const { expect }       = require('chai')
-const { readFileSync } = require('fs')
-
-const loadSync = (yamlPath) => {
-  const id     = yamlPath.split('.')[0].split('/').reverse()[0]
-  const source = load(readFileSync(yamlPath))
-
-  return new Schema(source, id)
-}
-
-describe('Schema', () => {
-  describe('Schema.constructor(source = {}, id = UNDEFINED_SCHEMA_ID)', () => {
-    it('creates empty schema with default id', () => {
-      const schema = new Schema()
-
-      expect(schema.id).to.equal('UNDEFINED_SCHEMA_ID')
-      expect(schema.source).to.be.empty
-    })
-
-    it('extends schema properties with types', () => {
-      const schema = loadSync('examples/Profile.yaml')
-
-      expect(schema.source.name.type).to.eql('string')
-      expect(schema.source.gender.type).to.eql('string')
-      expect(schema.source.tags.items.type).to.eql('string')
-      expect(schema.source.favoriteItems.type).to.eql('array')
-      expect(schema.source.favoriteItems.items.type).to.not.exist
-      expect(schema.source.locations.type).to.eql('array')
-      expect(schema.source.locations.items.type).to.eql('object')
-      expect(schema.source.locations.items.properties.name.type).to.eql('string')
-      expect(schema.source.locations.items.properties.address.type).to.eql('object')
-      expect(schema.source.locations.items.properties.address.properties.zip.type).to.eql('string')
-      expect(schema.source.locations.items.properties.address.properties.city.type).to.eql('string')
-      expect(schema.source.locations.items.properties.address.properties.country.type).to.eql('string')
-      expect(schema.source.locations.items.properties.address.properties.addressLine1.type).to.eql('string')
-      expect(schema.source.locations.items.properties.address.properties.addressLine2.type).to.eql('string')
-
-      const stringEnumSchema = new Schema({ enum: [ 'L', 'M', 'S'] }, 'Size')
-
-      expect(stringEnumSchema.source.type).to.eql('string')
-
-      const numbersEnumSchema = new Schema({ enum: [ 1, 2, 3 ], type: 'number' }, 'Points')
-
-      expect(numbersEnumSchema.source.type).to.eql('number')
-    })
-
-    it('creates schema from other schemas source', () => {
-      const entitySchema = new Schema({ name: { type: 'string' } }, 'Entity')
-
-      const schema = new Schema(entitySchema, 'EntityClone')
-
-      expect(schema.id).to.equal('EntityClone')
-      expect(schema.source).to.deep.equal(entitySchema.source)
-    })
-  })
-
-  describe('.pure(id)', () => {
-    it('returns schema without required and default attributes', () => {
-      const profileSchema = loadSync('examples/Profile.yaml')
-      const updateProfileSchema = profileSchema.pure('UpdateProfile')
-
-      expect(updateProfileSchema.id).to.eql('UpdateProfile')
-
-      const { source } = updateProfileSchema
-
-      expect(source.name.required).to.not.exist
-      expect(source.gender.default).to.not.exist
-      expect(source.contactDetails.required).to.not.exist
-      expect(source.contactDetails.properties.email.required).to.not.exist
-      expect(source.contactDetails.properties.mobileNumber.default).to.not.exist
-      expect(source.locations.items.properties.name.require).to.not.exist
-      expect(source.locations.items.properties.address.properties.country.required).to.not.exist
-      expect(source.locations.items.properties.address.properties.country.default).to.not.exist
-      expect(source.locations.items.properties.address.properties.city.required).to.not.exist
-      expect(source.locations.items.properties.address.properties.addressLine1.required).to.not.exist
-      expect(source.locations.items.properties.address.properties.addressLine2.required).to.not.exist
-      expect(source.locations.items.properties.address.properties.zip.required).to.not.exist
-    })
-  })
-
-  describe('.clone(id)', () => {
-    it('returns schema clone', () => {
-      const profileSchema = loadSync('examples/Profile.yaml')
-
-      const schema = profileSchema.clone('ProfileClone')
-      expect(schema.id).to.eql('ProfileClone')
-    })
-  })
-
-  describe('.only(propertyNames, id)', () => {
-    it('returns schema with only requested properties', () => {
-      const profileSchema = loadSync('examples/Profile.yaml')
-
-      const schema = profileSchema.only([ 'name', 'gender' ], 'ProfileClone')
-      expect(schema.id).to.eql('ProfileClone')
-    })
-  })
-
-  describe('.extend(properties, id)', () => {
-    it('returns schema extended with specified properties', () => {
-      const profileSchema = loadSync('examples/Profile.yaml')
-
-      const documentSource = {
-        createdAt: {
-          type:    'string',
-          format:  'date-time',
-          required: true
-        }
-      }
-
-      const profileDocumentSchema = profileSchema.extend(documentSource, 'ProfileDocument')
-
-      expect(profileDocumentSchema.id).to.eql('ProfileDocument')
-      expect(profileDocumentSchema.source.createdAt).to.exist
-    })
-  })
-
-  describe('.wrap(propertyName, options = { required: true }, id)', () => {
-    it('returns schema that wraps source schema with object property', () => {
-      const profileSchema = loadSync('examples/Profile.yaml')
-
-      const dataSchema = profileSchema.wrap('data')
-      expect(dataSchema.id).to.eql('UNDEFINED_SCHEMA_ID')
-      expect(dataSchema.source.data).to.exist
-      expect(dataSchema.source.data.required).to.exist
-
-      const alternativeDataSchema = profileSchema.wrap('data', { default: {} }, 'ResponseOutput')
-      expect(alternativeDataSchema.id).to.eql('ResponseOutput')
-      expect(alternativeDataSchema.source.data).to.exist
-      expect(alternativeDataSchema.source.data.default).to.exist
-      expect(alternativeDataSchema.source.data.required).to.not.exist
-    })
-  })
-
-  describe('.jsonSchema', () => {
-    it('returns json schema for enum type', () => {
-      const source = {
-        type: 'string',
-        enum: [ 'L', 'M', 'S' ]
-      }
-
-      const sizeSchema = new Schema(source, 'Size')
-
-      expect(sizeSchema.jsonSchema.id).to.eql('Size')
-      expect(sizeSchema.jsonSchema.type).to.eql('string')
-      expect(sizeSchema.jsonSchema.enum).to.deep.equal(source.enum)
-    })
-
-    it('returns json schema with normalized required attributes', () => {
-      const profileSchema = loadSync('examples/Profile.yaml')
-
-      const { jsonSchema } = profileSchema
-
-      expect(jsonSchema).to.have.property('type', 'object')
-      expect(jsonSchema).to.have.property('properties')
-      expect(jsonSchema.required).to.deep.equal([ 'name', 'contactDetails' ])
-      expect(jsonSchema.properties.contactDetails.required).to.deep.equal([ 'email' ])
-    })
-
-    it('returns json schema without required attributes', () => {
-      const schema = new Schema({ name: { type: 'string' } }, 'Entity')
-
-      const { jsonSchema } = schema
-
-      expect(jsonSchema.required).to.not.exist
-    })
-  })
-})

package/src/ValidationError.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const { pick } = require('lodash')
-
-class ValidationError extends Error {
-  constructor(schemaId, invalidObject, validationErrors) {
-    super(`"${schemaId}" validation failed`)
-
-    this._object   = invalidObject
-    this._schemaId = schemaId
-    this._validationErrors = validationErrors.map(error => pick(error, [
-      'path',
-      'code',
-      'params',
-      'message',
-      'schemaId'
-    ]))
-  }
-
-  toJSON() {
-    return {
-      code:             this.constructor.name,
-      object:           this._object,
-      message:          this.message,
-      schemaId:         this._schemaId,
-      validationErrors: this._validationErrors
-    }
-  }
-}
-
-module.exports = ValidationError

package/src/Validator.js

@@ -1,128 +0,0 @@
-'use strict'
-
-const { keyBy, groupBy }  = require('lodash')
-const ZSchema             = require('z-schema')
-const cleanupNulls        = require('./helpers/cleanupNulls')
-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 {
-  constructor(schemas = []) {
-    if (schemas.length === 0) {
-      throw new Error('No schemas provided')
-    }
-
-    const groupsById = groupBy(schemas, 'id')
-
-    for (const id in groupsById) {
-      const schemas       = groupsById[id]
-      const hasDuplicates = schemas.length > 1
-
-      if (hasDuplicates) {
-        throw new Error(`Multiple "${id}" schemas provided`)
-      }
-    }
-
-    this._engine = new ZSchema({
-      reportPathAsArray: false,
-      ignoreUnknownFormats: true,
-    })
-
-    const jsonSchemas = schemas.map(({ jsonSchema }) => jsonSchema)
-    const isValid     = this._engine.validateSchema(jsonSchemas)
-
-    if (!isValid) {
-      const json = JSON.stringify(this._engine.lastReport.errors, null, 2)
-      throw new Error(`Schemas validation failed:\n${json}`)
-    }
-
-    this._schemasMap     = keyBy(schemas, 'id')
-    this._jsonSchemasMap = keyBy(jsonSchemas, 'id')
-  }
-
-  validate(object, schemaId, shouldNullifyEmptyValues = false, shouldCleanupNulls = false) {
-    const jsonSchema = this._jsonSchemasMap[schemaId]
-
-    if (!jsonSchema) {
-      throw new Error(`Schema "${schemaId}" not found`)
-    }
-
-    const objectJson = JSON.stringify(object)
-    let result = JSON.parse(objectJson)
-
-    if (shouldCleanupNulls) {
-      result = cleanupNulls(result)
-    }
-
-    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)
-
-    // eslint-disable-next-line no-unused-vars
-    } 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)
-
-    if (isValid) {
-      return result
-    }
-
-    let validationErrors = this._engine.getLastErrors()
-
-    if (!shouldNullifyEmptyValues) {
-      throw new ValidationError(schemaId, result, validationErrors)
-    }
-
-    const [ updatedResult, updatedValidationErrors ] = nullifyEmptyValues(result, validationErrors)
-
-    const hasValidationErrors = updatedValidationErrors.length > 0
-
-    if (hasValidationErrors) {
-      throw new ValidationError(schemaId, result, updatedValidationErrors)
-    }
-
-    return updatedResult
-  }
-
-  normalize(object, schemaId) {
-    const jsonSchema = this._jsonSchemasMap[schemaId]
-
-    if (!jsonSchema) {
-      throw new Error(`Schema "${schemaId}" not found`)
-    }
-
-    const result = JSON.parse(JSON.stringify(object))
-    normalizeAttributes(result, jsonSchema, this._jsonSchemasMap)
-
-    return result
-  }
-
-  get schemasMap() {
-    return this._schemasMap
-  }
-
-  getReferenceIds(schemaId) {
-    const schema = this._schemasMap[schemaId]
-    return getReferenceIds(schema, this._schemasMap)
-  }
-}
-
-module.exports = Validator

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' ])
-    })
-  })
-})