@superhero/core 1.8.4 → 4.0.0-beta.1

package/composer/filter/integer/index.js

@@ -1,38 +0,0 @@
-/**
- * @implements {ComposerFilter}
- */
-class ComposerFilterInteger
-{
-  filter(options, data)
-  {
-    return options.collection
-    ? this.filterCollection(data)
-    : this.filterSingle(data)
-  }
-
-  filterCollection(data)
-  {
-    if(!Array.isArray(data))
-      return data
-
-    const collection = []
-
-    for(const item of data)
-    {
-      const filtered = this.filterSingle(item)
-      collection.push(filtered)
-    }
-
-    return collection
-  }
-
-  filterSingle(data)
-  {
-    if(isNaN(data) === false)
-      return +data
-
-    return data
-  }
-}
-
-module.exports = ComposerFilterInteger

package/composer/filter/integer/locator.js

@@ -1,11 +0,0 @@
-const ComposerFilterInteger = require('.')
-
-class ComposerFilterIntegerLocator
-{
-  locate()
-  {
-    return new ComposerFilterInteger
-  }
-}
-
-module.exports = ComposerFilterIntegerLocator

package/composer/filter/json/index.js

@@ -1,23 +0,0 @@
-/**
- * @implements {ComposerFilter}
- */
-class ComposerFilterJson
-{
-  filter(options, data)
-  {
-    try
-    {
-      return options.stringified
-      ? JSON.stringify(data, null, options.indentation)
-      : data
-    }
-    catch(error)
-    {
-      // it's not up to the filter to validate
-      // if we can't filter the data, then we simply pass the data forward
-      return data
-    }
-  }
-}
-
-module.exports = ComposerFilterJson

package/composer/filter/json/locator.js

@@ -1,11 +0,0 @@
-const ComposerFilterString = require('.')
-
-class ComposerFilterStringLocator
-{
-  locate()
-  {
-    return new ComposerFilterString
-  }
-}
-
-module.exports = ComposerFilterStringLocator

package/composer/filter/schema/error/missing-schema-definition.js

@@ -1,13 +0,0 @@
-/**
- * @extends {Error}
- */
-class MissingSchemaDefinitionError extends Error
-{
-  constructor(...a)
-  {
-    super(...a)
-    this.code = 'E_MISSING_SCHEMA_DEFINITION'
-  }
-}
-
-module.exports = MissingSchemaDefinitionError

package/composer/filter/schema/index.js

@@ -1,49 +0,0 @@
-const MissingSchemaDefinitionError = require('./error/missing-schema-definition')
-/**
- * @implements {ComposerFilter}
- */
-class ComposerFilterSchema
-{
-  constructor(composer)
-  {
-    this.composer = composer
-  }
-
-  filter(options, data)
-  {
-    return options.collection
-    ? this.filterCollection(options, data)
-    : this.filterSingle(options, data)
-  }
-
-  filterCollection(options, data)
-  {
-    if(!Array.isArray(data))
-      return data
-
-    const collection = []
-
-    for(const item of data)
-    {
-      const filtered = this.filterSingle(options, item)
-      collection.push(filtered)
-    }
-
-    return collection
-  }
-
-  filterSingle(options, data)
-  {
-    if(typeof options.schema === 'string')
-    {
-      return this.composer.compose(options.schema, data)
-    }
-    else
-    {
-      const msg = `Expected the attribute "schema" to define what type/schema to filter by`
-      throw new MissingSchemaDefinitionError(msg)
-    }
-  }
-}
-
-module.exports = ComposerFilterSchema

package/composer/filter/schema/locator.js

@@ -1,17 +0,0 @@
-const ComposerFilterSchema = require('.')
-
-class ComposerFilterSchemaLocator
-{
-  constructor(locator)
-  {
-    this.locator = locator
-  }
-
-  locate()
-  {
-    const composer = this.locator.locate('composer')
-    return new ComposerFilterSchema(composer)
-  }
-}
-
-module.exports = ComposerFilterSchemaLocator

package/composer/filter/string/index.js

@@ -1,50 +0,0 @@
-/**
- * @implements {ComposerFilter}
- */
-class ComposerFilterString
-{
-  filter(options, data)
-  {
-    return options.collection
-    ? this.filterCollection(options, data)
-    : this.filterSingle(options, data)
-  }
-
-  filterCollection(options, data)
-  {
-    if(!Array.isArray(data))
-      return data
-
-    const collection = []
-
-    for(const item of data)
-    {
-      const filtered = this.filterSingle(options, item)
-      collection.push(filtered)
-    }
-
-    return collection
-  }
-
-  filterSingle(options, data)
-  {
-    if(typeof data === 'number')
-      data = `${data}`
-
-    if(typeof data === 'boolean')
-      data = `${data}`
-
-    if(typeof data === 'string')
-    {
-      if(options.uppercase)
-        data = data.toUpperCase()
-
-      if(options.lowercase)
-        data = data.toLowerCase()
-    }
-
-    return data
-  }
-}
-
-module.exports = ComposerFilterString

package/composer/filter/string/locator.js

@@ -1,11 +0,0 @@
-const ComposerFilterString = require('.')
-
-class ComposerFilterStringLocator
-{
-  locate()
-  {
-    return new ComposerFilterString
-  }
-}
-
-module.exports = ComposerFilterStringLocator

package/composer/filter/timestamp/index.js

@@ -1,45 +0,0 @@
-/**
- * @implements {ComposerFilter}
- */
-class ComposerFilterTimestamp
-{
-  filter(options, data)
-  {
-    return options.collection
-    ? this.filterCollection(options, data)
-    : this.filterSingle(options, data)
-  }
-
-  filterCollection(options, data)
-  {
-    if(!Array.isArray(data))
-      return data
-
-    const collection = []
-
-    for(const item of data)
-    {
-      const filtered = this.filterSingle(options, item)
-      collection.push(filtered)
-    }
-
-    return collection
-  }
-
-  filterSingle(options, data)
-  {
-    const intData = parseInt(data)
-    if(intData == data)
-      data = intData
-
-    if(options.utc)
-      data = new Date(data).toUTCString()
-
-    if(options.json)
-      data = new Date(data).toJSON()
-
-    return data
-  }
-}
-
-module.exports = ComposerFilterTimestamp

package/composer/filter/timestamp/locator.js

@@ -1,11 +0,0 @@
-const ComposerFilterTimestamp = require('.')
-
-class ComposerFilterTimestampLocator
-{
-  locate()
-  {
-    return new ComposerFilterTimestamp
-  }
-}
-
-module.exports = ComposerFilterTimestampLocator

package/composer/index.js

@@ -1,180 +0,0 @@
-const
-InvalidAttributeError               = require('./error/invalid-attribute'),
-InvalidCollectionError              = require('./error/invalid-collection'),
-InvalidSchemaError                  = require('./error/invalid-schema'),
-SchemaNotFoundError                 = require('./error/schema-not-found'),
-FilterIsNotHoneringContractError    = require('./error/filter-is-not-honering-contract'),
-ValidatorIsNotHoneringContractError = require('./error/validator-is-not-honering-contract'),
-ValidatorNotFoundError              = require('./error/validator-not-found')
-
-class Composer
-{
-  constructor(deepmerge)
-  {
-    this.deepmerge  = deepmerge
-    this.schemas    = {}
-    this.filters    = {}
-    this.validators = {}
-  }
-
-  /**
-   * @param {string} name
-   * @param {...Object} dto
-   *
-   * @throws {E_SCHEMA_NOT_FOUND}
-   * @throws {E_VALIDATOR_NOT_FOUND}
-   * @throws {E_COMPOSER_INVALID_ATTRIBUTE}
-   *
-   * @returns {Object}
-   */
-  compose(name, ...dto)
-  {
-    if(name in this.schemas === false)
-    {
-      const msg = `Schema: "${name}" not found`
-      throw new SchemaNotFoundError(msg)
-    }
-
-    dto = this.deepmerge.merge({}, ...dto)
-
-    const
-    schema = this.schemas[name],
-    output = {}
-
-    for(const attribute in schema)
-    {
-      const options = schema[attribute]
-
-      output[attribute] = dto[attribute]
-
-      if('default' in options
-      && output[attribute] === undefined)
-      {
-        output[attribute] = options.default
-      }
-
-      // if optional, and undefined or null, then we don't need to filter or validate
-      if(options.optional  === true
-      && output[attribute] === undefined)
-      {
-        delete output[attribute]
-        continue
-      }
-
-      if(options.nullable  === true
-      && output[attribute] === null)
-      {
-        continue
-      }
-
-      // Filtering attributes if a filter has been defined for the type
-      if(options.type in this.filters)
-      {
-        const filter = this.filters[options.type]
-        output[attribute] = filter.filter(options, output[attribute])
-      }
-
-      // Validating type
-      if(options.type in this.validators === false)
-      {
-        const msg = `Validator: "${options.type}" not found`
-        throw new ValidatorNotFoundError(msg)
-      }
-
-      try
-      {
-        const validator = this.validators[options.type]
-
-        if(options.collection)
-        {
-          if(!Array.isArray(output[attribute]))
-          {
-            const msg = `Invalid type: "${typeof output[attribute]}", array expected`
-            throw new InvalidCollectionError(msg)
-          }
-
-          for(const item of output[attribute])
-          {
-            validator.valid(options, item)
-          }
-        }
-        else
-        {
-          validator.valid(options, output[attribute])
-        }
-      }
-      catch(error)
-      {
-        const msg = `Invalid attribute: "${attribute}", error: ${error.message}`
-        throw new InvalidAttributeError(msg)
-      }
-    }
-
-    return output
-  }
-
-  /**
-   * @param {string} schemaName
-   * @param {Object} schema
-   * @throws {E_COMPOSER_INVALID_SCHEMA}
-   */
-  addSchema(schemaName, schema)
-  {
-    if(typeof schema !== 'object')
-    {
-      const msg = `Schema "${schemaName}" must be an object`
-      throw new InvalidSchemaError(msg)
-    }
-
-    for(const attribute in schema)
-    {
-      if(typeof schema[attribute].type !== 'string')
-      {
-        const msg = `Attribute "${attribute}" does not have a type defined`
-        throw new InvalidSchemaError(msg)
-      }
-
-      if('enum' in schema[attribute] && !Array.isArray(schema[attribute].enum))
-      {
-        const msg = `Attribute "${attribute}" enum must be an array`
-        throw new InvalidSchemaError(msg)
-      }
-    }
-
-    this.schemas[schemaName] = schema
-  }
-
-  /**
-   * @param {string} filterName
-   * @param {ComposerFilter} filter
-   * @throws {E_FILTER_IS_NOT_HONERING_CONTRACT}
-   */
-  addFilter(filterName, filter)
-  {
-    if(typeof filter.filter !== 'function')
-    {
-      const msg = `Filter "${filterName}" not honering contract`
-      throw new FilterIsNotHoneringContractError(msg)
-    }
-
-    this.filters[filterName] = filter
-  }
-
-  /**
-   * @param {string} validatorName
-   * @param {ComposerValidator} validator
-   * @throws {E_VALIDATOR_IS_NOT_HONERING_CONTRACT}
-   */
-  addValidator(validatorName, validator)
-  {
-    if(typeof validator.valid !== 'function')
-    {
-      const msg = `Validator "${validatorName}" not honering contract`
-      throw new ValidatorIsNotHoneringContractError(msg)
-    }
-
-    this.validators[validatorName] = validator
-  }
-}
-
-module.exports = Composer

package/composer/locator.js

@@ -1,17 +0,0 @@
-const Composer = require('.')
-
-class ComposerLocator
-{
-  constructor(locator)
-  {
-    this.locator = locator
-  }
-
-  locate()
-  {
-    const deepmerge = this.locator.locate('deepmerge')
-    return new Composer(deepmerge)
-  }
-}
-
-module.exports = ComposerLocator

package/composer/validator/boolean/error/invalid.js

@@ -1,13 +0,0 @@
-/**
- * @extends {Error}
- */
-class InvalidBooleanError extends Error
-{
-  constructor(...a)
-  {
-    super(...a)
-    this.code = 'E_INVALID_BOOLEAN'
-  }
-}
-
-module.exports = InvalidBooleanError

package/composer/validator/boolean/index.js

@@ -1,17 +0,0 @@
-const InvalidBooleanError = require('./error/invalid')
-/**
- * @implements {ComposerValidator}
- */
-class ComposerValidatorBoolean
-{
-  valid(options, data)
-  {
-    if(typeof data !== 'boolean')
-    {
-      const msg = `Invalid type: "${typeof data}", boolean expected`
-      throw new InvalidBooleanError(msg)
-    }
-  }
-}
-
-module.exports = ComposerValidatorBoolean

package/composer/validator/boolean/locator.js

@@ -1,11 +0,0 @@
-const ComposerValidatorBoolean = require('.')
-
-class ComposerValidatorBooleanLocator
-{
-  locate()
-  {
-    return new ComposerValidatorBoolean
-  }
-}
-
-module.exports = ComposerValidatorBooleanLocator

package/composer/validator/decimal/error/invalid.js

@@ -1,13 +0,0 @@
-/**
- * @extends {Error}
- */
-class InvalidDecimalError extends Error
-{
-  constructor(...a)
-  {
-    super(...a)
-    this.code = 'E_INVALID_DECIMAL'
-  }
-}
-
-module.exports = InvalidDecimalError

package/composer/validator/decimal/index.js

@@ -1,59 +0,0 @@
-const InvalidDecimalError = require('./error/invalid')
-/**
- * @implements {ComposerValidator}
- */
-class ComposerValidatorDecimal
-{
-  valid(options, data)
-  {
-    if(typeof data !== 'number')
-    {
-      const msg = `Invalid type: "${typeof data}", number expected`
-      throw new InvalidDecimalError(msg)
-    }
-
-    if(options.unsigned
-    && data < 0)
-    {
-      const msg = `Expected an unsigned decimal`
-      throw new InvalidDecimalError(msg)
-    }
-
-    if('min' in options
-    && data < options.min)
-    {
-      const msg = `Decimal must be minimum: "${options.min}"`
-      throw new InvalidDecimalError(msg)
-    }
-
-    if('max' in options
-    && data > options.max)
-    {
-      const msg = `Decimal can't be more then: "${options.max}"`
-      throw new InvalidDecimalError(msg)
-    }
-
-    if('gt' in options
-    && data > options.gt)
-    {
-      const msg = `Decimal must be more then: "${options.gt}"`
-      throw new InvalidDecimalError(msg)
-    }
-
-    if('lt' in options
-    && data < options.lt)
-    {
-      const msg = `Decimal must be less then: "${options.lt}"`
-      throw new InvalidDecimalError(msg)
-    }
-
-    if(options.enum
-    &&!options.enum.includes(data))
-    {
-      const msg = `Expected one of the enumeral values: "${options.enum}"`
-      throw new InvalidDecimalError(msg)
-    }
-  }
-}
-
-module.exports = ComposerValidatorDecimal

package/composer/validator/decimal/locator.js

@@ -1,11 +0,0 @@
-const ComposerValidatorDecimal = require('.')
-
-class ComposerValidatorDecimalLocator
-{
-  locate()
-  {
-    return new ComposerValidatorDecimal
-  }
-}
-
-module.exports = ComposerValidatorDecimalLocator

package/composer/validator/index.js

@@ -1,10 +0,0 @@
-/**
- * @interface ComposerValidator
- */
-
-/**
- * @function ComposerValidator#valid
- * @param {Object} options
- * @param {*} data
- * @returns {void}
- */

package/composer/validator/integer/error/invalid.js

@@ -1,13 +0,0 @@
-/**
- * @extends {Error}
- */
-class InvalidIntegerError extends Error
-{
-  constructor(...a)
-  {
-    super(...a)
-    this.code = 'E_INVALID_INTEGER'
-  }
-}
-
-module.exports = InvalidIntegerError