@kravc/schema 2.7.6 → 2.8.0-alpha.1

package/src/CredentialFactory.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const Schema        = require('./Schema')
-const Validator     = require('./Validator')
-const validateId    = require('./helpers/validateId')
-const { constants } = require('credentials-context')
-
-const { CREDENTIALS_CONTEXT_V1_URL } = constants
-
-class CredentialFactory {
-  // TODO: Add exception when added two schemas with the same name.
-  constructor(uri, schemas) {
-    validateId('uri', uri)
-
-    this._types = [].concat(schemas).map(schema => {
-      if (schema.url) {
-        return schema
-      }
-
-      return new Schema(schema, schema.id, uri)
-    })
-
-    this._uri       = uri
-    this._context   = {}
-    this._validator = new Validator(this._types)
-
-    for (const { id, linkedDataType } of this._types) {
-      this._context[id] = linkedDataType
-    }
-  }
-
-  get credentialType() {
-    const [ credentialType ] = this._uri.split('/').reverse()
-
-    return credentialType
-  }
-
-  get context() {
-    return {
-      [this.credentialType]: { '@id': this._uri },
-      ...this._context
-    }
-  }
-
-  createCredential(id, holder, subject = {}) {
-    validateId('id', id)
-    validateId('holder', holder)
-
-    const type = [ 'VerifiableCredential', this.credentialType ]
-
-    const [ rootType ]      = this._types
-    const credentialSubject = this._validator.validate(subject, rootType.id)
-
-    return {
-      '@context': [
-        CREDENTIALS_CONTEXT_V1_URL,
-        this.context
-      ],
-      id,
-      type,
-      holder,
-      credentialSubject
-    }
-  }
-}
-
-module.exports = CredentialFactory

package/src/CredentialFactory.spec.js

@@ -1,131 +0,0 @@
-'use strict'
-
-const Schema            = require('./Schema')
-const { expect }        = require('chai')
-const { canonize }      = require('jsonld')
-const documentLoader    = require('./ld/documentLoader')
-const CredentialFactory = require('./CredentialFactory')
-const {
-  createAccountCredential,
-  createMineSweeperScoreCredential
-} = require('examples')
-
-describe('CredentialFactory', () => {
-  describe('CredentialFactory.constructor(uri, schemas)', () => {
-    it('throws error if "uri" parameter is missing', () => {
-      expect(
-        () => new CredentialFactory()
-      ).to.throw()
-    })
-
-    it('throws error if "uri" parameter is not a URL', () => {
-      expect(
-        () => new CredentialFactory('BAD_URL')
-      ).to.throw()
-    })
-  })
-
-  describe('.createCredential(id, holder, subject = {}, subjectTypeId = null)', () => {
-    let factory
-
-    before(() => {
-      const videoGameSchema = new Schema({
-        id:      {},
-        name:    { type: 'string', required: true },
-        version: { type: 'string', required: true }
-      }, 'VideoGame', 'https://schema.org/')
-
-      factory = new CredentialFactory('https://example.com/StarCraft', videoGameSchema)
-    })
-
-    it('returns single schema based credential', async () => {
-      const credential = await createAccountCredential('did:PLAYER_ID', 'CAHTEP')
-
-      expect(credential).to.exist
-      await canonize(credential, { documentLoader })
-
-      const { credentialSubject: { createdAt } } = credential
-      expect(credential).to.eql({
-        '@context': [
-          'https://www.w3.org/2018/credentials/v1',
-          {
-            AccountV1: { '@id': 'https://example.com/schema/AccountV1' },
-            Account: {
-              '@id': 'https://example.com/schema/AccountV1#Account',
-              '@context': {
-                '@vocab': 'https://example.com/schema/AccountV1#',
-                '@version': 1.1,
-                '@protected': true,
-                schema: 'https://schema.org/',
-                username: { '@id': 'username' },
-                createdAt: { '@id': 'createdAt', '@type': 'schema:DateTime' },
-                dateOfBirth: { '@id': 'dateOfBirth', '@type': 'schema:Date' }
-              }
-            }
-          }
-        ],
-        id: 'https://example.com/account/CAHTEP',
-        type: [ 'VerifiableCredential', 'AccountV1' ],
-        holder: 'did:PLAYER_ID',
-        credentialSubject: {
-          id: 'did:PLAYER_ID',
-          username: 'CAHTEP',
-          createdAt,
-          type: 'Account'
-        }
-      })
-    })
-
-    it('returns multiple schemas based credential', async () => {
-      const playerScore = {
-        wins:          5,
-        losses:        5,
-        winRate:       50,
-        UNDEFINED:     'VALUE',
-        bestScore:     23450,
-        endurance:     'P5M22S',
-        dateCreated:   '2020-10-10T00:00:00Z',
-        bestRoundTime: 10000
-      }
-
-      const credential = await createMineSweeperScoreCredential(
-        'did:GAME_ID',
-        'did:PLAYER_ID',
-        playerScore
-      )
-
-      expect(credential).to.exist
-      await canonize(credential, { documentLoader })
-
-      const { credentialSubject } = credential
-      expect(credentialSubject.type).to.equal('Player')
-      expect(credentialSubject.hasVideoGameScore.type).to.equal('VideoGameScore')
-      expect(credentialSubject.hasVideoGameScore.game.type).to.equal('VideoGame')
-      expect(credentialSubject.hasVideoGameScore.UNDEFINED).to.not.exist
-
-      const customContext = credential['@context'][1]
-      expect(customContext.VideoGame).to.eql({
-        '@id': 'https://schema.org/VideoGame',
-        '@context': {
-          '@protected': true,
-          '@version': 1.1,
-          '@vocab': 'https://schema.org/',
-          name: { '@id': 'name' },
-          version: { '@id': 'version' }
-        }
-      })
-    })
-
-    it('throws error if "id" parameter is missing', () => {
-      expect(
-        () => factory.createCredential()
-      ).to.throw('Parameter "id" is required')
-    })
-
-    it('throws error if "holder" parameter is missing', () => {
-      expect(
-        () => factory.createCredential('did:CREDENTIAL_ID')
-      ).to.throw('Parameter "holder" is required')
-    })
-  })
-})

package/src/Schema.js

@@ -1,104 +0,0 @@
-'use strict'
-
-const { pick, cloneDeep }  = require('lodash')
-const validateId           = require('./helpers/validateId')
-const normalizeRequired    = require('./helpers/normalizeRequired')
-const normalizeProperties  = require('./helpers/normalizeProperties')
-const getLinkedDataContext = require('./ld/getLinkedDataContext')
-const removeRequiredAndDefault = require('./helpers/removeRequiredAndDefault')
-
-const UNDEFINED_SCHEMA_ID = 'UNDEFINED_SCHEMA_ID'
-
-class Schema {
-  constructor(source = {}, id = UNDEFINED_SCHEMA_ID, url) {
-    this._id     = id
-    this._url    = url
-    this._source = source instanceof Schema ? source.source : source
-
-    if (url) {
-      validateId('url', url)
-
-      this._source.type = { required: true, type: 'string', default: id }
-
-      if (this._source.id) {
-        this._source.id = { required: true, type: 'string', format: 'url' }
-      }
-
-      const uri =
-        (url.endsWith('/') || url.endsWith('#')) ? `${url}${id}` : `${url}#${id}`
-
-      this._linkedDataType = {
-        '@id':      uri,
-        '@context': getLinkedDataContext(this._source, url)
-      }
-    }
-
-    normalizeProperties(this._source)
-  }
-
-  get id() {
-    return this._id
-  }
-
-  get url() {
-    return this._url
-  }
-
-  get source() {
-    return cloneDeep(this._source)
-  }
-
-  get jsonSchema() {
-    if (this._source.enum) {
-      return {
-        id: this._id,
-        ...this.source
-      }
-    }
-
-    const jsonSchema = {
-      id:         this._id,
-      type:       'object',
-      properties: this.source
-    }
-
-    normalizeRequired(jsonSchema)
-
-    return jsonSchema
-  }
-
-  get linkedDataType() {
-    return this._linkedDataType
-  }
-
-  clone(id) {
-    return new Schema(this.source, id)
-  }
-
-  pure(id) {
-    const { properties: source } = removeRequiredAndDefault({ properties: this.source })
-    return new Schema(source, id)
-  }
-
-  only(propertyNames, id) {
-    const source = pick(this.source, propertyNames)
-    return new Schema(source, id)
-  }
-
-  extend(properties, id) {
-    return new Schema({ ...this.source, ...properties }, id)
-  }
-
-  wrap(propertyName, options = { required: true }, id) {
-    const source = {
-      [propertyName]: {
-        properties: this.source,
-        ...options
-      }
-    }
-
-    return new Schema(source, id)
-  }
-}
-
-module.exports = Schema

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