@kravc/schema 2.7.6 → 2.8.0-alpha.0

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

package/src/helpers/normalizeRequired.js

@@ -1,37 +0,0 @@
-'use strict'
-
-const normalizeRequired = jsonSchema => {
-  const { properties } = jsonSchema
-
-  if (!properties) { return }
-
-  const required = []
-  for (const name in properties) {
-    const property = properties[name]
-
-    if (property.required) {
-      property['x-required'] = true
-      required.push(name)
-    }
-
-    delete properties[name].required
-
-    const isObject = property.type === 'object'
-    const isArray  = property.type === 'array'
-
-    if (isObject) {
-      normalizeRequired(property)
-    }
-
-    if (isArray) {
-      const { items: itemJsonSchema } = property
-      normalizeRequired(itemJsonSchema)
-    }
-  }
-
-  if (required.length > 0) {
-    jsonSchema.required = required
-  }
-}
-
-module.exports = normalizeRequired

package/src/helpers/normalizeType.js

@@ -1,41 +0,0 @@
-'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
-
-  const isNumber  = type === 'integer' || type === 'number'
-  const isBoolean = type === 'boolean'
-
-  if (isNumber) {
-    normalizedValue = Number(value) || value
-  }
-
-  if (isBoolean) {
-    const isNumberValue  = typeof value === 'number'
-    const isStringValue  = typeof value === 'string'
-
-    const shouldConvertValue = isNumberValue || isStringValue
-
-    if (shouldConvertValue) {
-      if (isNumberValue) {
-        normalizedValue = Boolean(value)
-      }
-
-      if (isStringValue) {
-        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
-        }
-      }
-    }
-  }
-
-  return normalizedValue
-}
-
-module.exports = normalizeType

package/src/helpers/nullifyEmptyValues.js

@@ -1,57 +0,0 @@
-'use strict'
-
-const { get, set } = require('lodash')
-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 } = 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 { path: pathString } = error
-    const path = pathString.replace('#/', '').split('/')
-
-    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

package/src/helpers/removeRequiredAndDefault.js

@@ -1,30 +0,0 @@
-'use strict'
-
-const removeRequiredAndDefault = jsonSchema => {
-  const { properties } = jsonSchema
-
-  if (!properties) { return }
-
-  for (const name in properties) {
-    const property = properties[name]
-
-    delete property.required
-    delete property.default
-
-    const isObject = property.type === 'object'
-    const isArray  = property.type === 'array'
-
-    if (isObject) {
-      removeRequiredAndDefault(property)
-    }
-
-    if (isArray) {
-      const { items: itemsJsonSchema } = property
-      removeRequiredAndDefault(itemsJsonSchema)
-    }
-  }
-
-  return { properties }
-}
-
-module.exports = removeRequiredAndDefault

package/src/helpers/validateId.js

@@ -1,19 +0,0 @@
-'use strict'
-
-const { isURL } = require('validator')
-
-const validateId = (name, value) => {
-  if (!value) {
-    throw new Error(`Parameter "${name}" is required`)
-  }
-
-  const isURI = value.toLowerCase().startsWith('did:') || isURL(value)
-
-  if (isURI) {
-    return
-  }
-
-  throw new Error(`Parameter "${name}" must be a URL, received: "${value}"`)
-}
-
-module.exports = validateId

package/src/index.d.ts

@@ -1,25 +0,0 @@
-declare type SchemaAttribute = object;
-export declare type SchemaAttributes = Record<string, SchemaAttribute>;
-declare type Enum = { enum: string[] };
-declare type Source = Enum | SchemaAttributes;
-
-export declare class Schema {
-  constructor(
-    source: Source,
-    id: string,
-    url?: string
-  )
-
-  get id(): string;
-  get source(): Source;
-
-  only(propertyNames: string[], id?: string): Schema;
-  wrap(propertyName: string, options?: Record<string, any>, id?: string): Schema;
-  extend(properties: Record<string, any>, id?: string): Schema;
-}
-
-export declare class Validator {
-  constructor(
-    schemas: Schema[]
-  )
-}

package/src/index.js

@@ -1,8 +0,0 @@
-'use strict'
-
-module.exports = {
-  Schema:            require('./Schema'),
-  Validator:         require('./Validator'),
-  documentLoader:    require('./ld/documentLoader'),
-  CredentialFactory: require('./CredentialFactory')
-}

package/src/ld/documentLoader.js

@@ -1,25 +0,0 @@
-'use strict'
-
-const { contexts: securityContextsMap }    = require('security-context')
-const { contexts: credentialsContextsMap } = require('credentials-context')
-
-const CONTEXTS = new Map([ ...securityContextsMap, ...credentialsContextsMap ])
-
-const documentLoader = documentUrl => {
-  const contextUrl = null
-  const [ url ] = documentUrl.split('#')
-
-  const document = CONTEXTS.get(url)
-
-  if (!document) {
-    throw new Error(`Custom context "${documentUrl}" is not supported`)
-  }
-
-  return {
-    document,
-    contextUrl,
-    documentUrl
-  }
-}
-
-module.exports = documentLoader

package/src/ld/documentLoader.spec.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { expect }     = require('chai')
-const documentLoader = require('./documentLoader')
-
-describe('documentLoader(documentUrl)', () => {
-  it('throws error if context not found', () => {
-    expect(
-      () => documentLoader('https://example.com')
-    ).to.throw('Custom context "https://example.com')
-  })
-})

package/src/ld/getLinkedDataContext.js

@@ -1,63 +0,0 @@
-'use strict'
-
-const getLinkedDataType = require('./getLinkedDataType')
-
-const SCHEMA_ORG_URI = 'https://schema.org/'
-
-const PROTECTED_PROPERTIES = [
-  'id',
-  'type',
-  'schema'
-]
-
-// TODO: Add support for embedded object, array and enum.
-const getLinkedDataContext = (properties, vocabUri) => {
-  const context = {}
-
-  for (const key in properties) {
-    const schema = properties[key]
-
-    const isProtected = PROTECTED_PROPERTIES.includes(key) || key.startsWith('@')
-
-    if (isProtected) {
-      continue
-    }
-
-    const { $ref } = schema
-
-    if ($ref) {
-      context[key] = { '@id': key }
-      continue
-    }
-
-    context[key] = { '@id': key }
-
-    const linkedDataType = getLinkedDataType(schema)
-
-    if (linkedDataType) {
-      context[key]['@type'] = linkedDataType
-    }
-  }
-
-  const vocab =
-    vocabUri.endsWith('/') || vocabUri.endsWith('#') ? vocabUri : `${vocabUri}#`
-
-  const contextHeader = {
-    '@vocab':     vocab,
-    '@version':   1.1,
-    '@protected': true
-  }
-
-  const isSchemaOrgDomain = vocab === SCHEMA_ORG_URI
-
-  if (!isSchemaOrgDomain) {
-    contextHeader.schema = SCHEMA_ORG_URI
-  }
-
-  return {
-    ...contextHeader,
-    ...context
-  }
-}
-
-module.exports = getLinkedDataContext