functional-models 1.1.20 → 1.2.0

package/src/properties.js

@@ -0,0 +1,313 @@
+const identity = require('lodash/identity')
+const get = require('lodash/get')
+const isFunction = require('lodash/isFunction')
+const merge = require('lodash/merge')
+const {
+  createPropertyValidator,
+  emptyValidator,
+  maxTextLength,
+  minTextLength,
+  minNumber,
+  maxNumber,
+  isType,
+  referenceTypeMatch,
+  meetsRegex,
+} = require('./validation')
+const { PROPERTY_TYPES } = require('./constants')
+const { lazyValue } = require('./lazy')
+const { toTitleCase, createUuid } = require('./utils')
+
+const createPropertyTitle = key => {
+  const goodName = toTitleCase(key)
+  return `get${goodName}`
+}
+
+const EMAIL_REGEX =
+  /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/u
+
+const _getValidatorFromConfigElseEmpty = (config, key, validatorGetter) => {
+  if (key in config) {
+    return validatorGetter(config[key])
+  }
+  return emptyValidator
+}
+
+const _mergeValidators = (config, validators) => {
+  return [...validators, ...(config.validators ? config.validators : [])]
+}
+
+const Property = (type, config = {}, additionalMetadata = {}) => {
+  if (!type && !config.type) {
+    throw new Error(`Property type must be provided.`)
+  }
+  if (config.type) {
+    type = config.type
+  }
+  const getConstantValue = () => config.value !== undefined ? config.value : undefined
+  const getDefaultValue = () => config.defaultValue !== undefined ? config.defaultValue : undefined
+  const getChoices = () => config.choices ? config.choices : []
+  const lazyLoadMethod = config.lazyLoadMethod || false
+  const valueSelector = config.valueSelector || identity
+  if (typeof valueSelector !== 'function') {
+    throw new Error(`valueSelector must be a function`)
+  }
+
+
+  return {
+    ...additionalMetadata,
+    getConfig: () => config,
+    getChoices,
+    getDefaultValue,
+    getConstantValue,
+    getPropertyType: () => type,
+    createGetter: instanceValue => {
+      const value = getConstantValue()
+      if (value !== undefined) {
+        return () => value
+      }
+      const defaultValue = getDefaultValue()
+      if (
+        defaultValue !== undefined &&
+        (instanceValue === null || instanceValue === undefined)
+      ) {
+        return () => defaultValue
+      }
+      const method = lazyLoadMethod
+        ? lazyValue(lazyLoadMethod)
+        : typeof instanceValue === 'function'
+        ? instanceValue
+        : () => instanceValue
+      return async () => {
+        return valueSelector(await method(instanceValue))
+      }
+    },
+    getValidator: valueGetter => {
+      const validator = createPropertyValidator(config)
+      const _propertyValidatorWrapper = async (instance, instanceData, options={}) => {
+        return validator(await valueGetter(), instance, instanceData, options)
+      }
+      return _propertyValidatorWrapper
+    },
+  }
+}
+
+const DateProperty = (config = {}, additionalMetadata={}) => Property(PROPERTY_TYPES.DateProperty, {
+  ...config,
+  lazyLoadMethod: value => {
+    if (!value && config.autoNow) {
+      return new Date()
+    }
+    return value
+  },
+}, additionalMetadata)
+
+const ReferenceProperty = (model, config = {}, additionalMetadata={}) => {
+  if (!model) {
+    throw new Error('Must include the referenced model')
+  }
+
+  const _getModel = () => {
+    if (isFunction(model)) {
+      return model()
+    }
+    return model
+  }
+
+  const validators = _mergeValidators(config, [referenceTypeMatch(model)])
+
+  const _getId = (instanceValues) => () => {
+    if (!instanceValues) {
+      return null
+    }
+    const theModel = _getModel()
+    const primaryKey = theModel.getPrimaryKeyName()
+    if (instanceValues[primaryKey]) {
+      return instanceValues[primaryKey]
+    }
+    const primaryKeyFunc = get(instanceValues, 'functions.getPrimaryKey')
+    if (primaryKeyFunc) {
+      return primaryKeyFunc()
+    }
+    return instanceValues
+  }
+
+  const lazyLoadMethod = async instanceValues => {
+
+    const valueIsModelInstance =
+      Boolean(instanceValues) && Boolean(instanceValues.functions)
+
+    const _getInstanceReturn = objToUse => {
+      // We need to determine if the object we just go is an actual model instance to determine if we need to make one.
+      const objIsModelInstance =
+        Boolean(objToUse) && Boolean(objToUse.functions)
+      const instance = objIsModelInstance
+        ? objToUse
+        : _getModel().create(objToUse)
+      return merge({}, instance, {
+        functions: {
+          toObj: _getId(instanceValues),
+        },
+      })
+    }
+
+    if (valueIsModelInstance) {
+      return _getInstanceReturn(instanceValues)
+    }
+    if (config.fetcher) {
+      const id = await _getId(instanceValues)()
+      const model = _getModel()
+      const obj = await config.fetcher(model, id)
+      return _getInstanceReturn(obj)
+    }
+    return _getId(instanceValues)()
+  }
+
+  return Property(
+    PROPERTY_TYPES.ReferenceProperty,
+    merge({}, config, {
+      validators,
+      lazyLoadMethod,
+    }),
+    {
+      ...additionalMetadata,
+      meta: {
+        getReferencedId: (instanceValues) => _getId(instanceValues)(),
+        getReferencedModel: _getModel,
+      },
+    }
+  )
+}
+
+const ArrayProperty = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.ArrayProperty,
+    {
+    defaultValue: [],
+    ...config,
+    isArray: true,
+  }, additionalMetadata)
+
+const ObjectProperty = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.ObjectProperty,
+    merge(config, {
+      validators: _mergeValidators(config, [isType('object')]),
+    }),
+    additionalMetadata
+  )
+
+const TextProperty = (config = {}, additionalMetadata={} ) =>
+  Property(
+    PROPERTY_TYPES.TextProperty,
+    merge(config, {
+      isString: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config, 'maxLength', value =>
+          maxTextLength(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'minLength', value =>
+          minTextLength(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+  )
+
+const IntegerProperty = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.IntegerProperty,
+    merge(config, {
+      isInteger: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
+          maxNumber(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+  )
+
+const NumberProperty = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.NumberProperty,
+    merge(config, {
+      isNumber: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
+          maxNumber(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+  )
+
+const ConstantValueProperty = (value, config = {}, additionalMetadata={}) =>
+  TextProperty(
+    merge(config, {
+      type: PROPERTY_TYPES.ConstantValueProperty,
+      value,
+    }),
+    additionalMetadata
+  )
+
+const EmailProperty = (config = {}, additionalMetadata={}) =>
+  TextProperty(
+    merge(config, {
+      type: PROPERTY_TYPES.EmailProperty,
+      validators: _mergeValidators(config, [meetsRegex(EMAIL_REGEX)]),
+    }),
+    additionalMetadata
+  )
+
+const BooleanProperty = (config = {}, additionalMetadata={}) => Property(
+  PROPERTY_TYPES.BooleanProperty,
+  merge(config, {
+      isBoolean: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
+          maxNumber(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+)
+
+const UniqueId = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.UniqueId,
+    {
+    ...config,
+    lazyLoadMethod: value => {
+      if (!value) {
+        return createUuid()
+      }
+      return value
+    },
+  }, additionalMetadata)
+
+
+
+module.exports = {
+  Property,
+  UniqueId,
+  DateProperty,
+  ArrayProperty,
+  ReferenceProperty,
+  IntegerProperty,
+  TextProperty,
+  ConstantValueProperty,
+  NumberProperty,
+  ObjectProperty,
+  EmailProperty,
+  BooleanProperty,
+  createPropertyTitle,
+}

package/src/serialization.js

@@ -0,0 +1,50 @@
+const { loweredTitleCase } = require('./utils')
+
+const SIZE_OF_GET = 'get'.length
+const IGNORABLE_KEYS = ['meta', 'functions']
+
+const _getValue = async value => {
+  if (value === undefined) {
+    return null
+  }
+  if (value === null) {
+    return null
+  }
+  const type = typeof value
+  if (type === 'function') {
+    return _getValue(await value())
+  }
+  // Nested Json
+  if (type === 'object' && value.functions && value.functions.toObj) {
+    return _getValue(await value.functions.toObj())
+  }
+  // Dates
+  if (type === 'object' && value.toISOString) {
+    return _getValue(value.toISOString())
+  }
+  return value
+}
+
+const _getKey = key => {
+  return key.startsWith('get') ? loweredTitleCase(key.slice(SIZE_OF_GET)) : key
+}
+
+const _shouldIgnoreKey = key => {
+  return IGNORABLE_KEYS.includes(key)
+}
+
+const toObj = keyToFunc => async () => {
+  return Object.entries(keyToFunc).reduce(async (acc, [key, value]) => {
+    const realAcc = await acc
+    if (_shouldIgnoreKey(key)) {
+      return realAcc
+    }
+    const keyToUse = _getKey(key)
+    const trueValue = await _getValue(value)
+    return { ...realAcc, [keyToUse]: trueValue }
+  }, Promise.resolve({}))
+}
+
+module.exports = {
+  toObj,
+}

package/src/utils.js

@@ -0,0 +1,52 @@
+const keyBy = require('lodash/keyBy')
+
+const HEX = 16
+const FOUR = 4
+const FIFTEEN = 15
+
+const getRandomValues = () => {
+  const array = new Uint8Array(1)
+  if (typeof window !== 'undefined') {
+    if (window.crypto) {
+      return window.crypto.getRandomValues(array)
+    }
+    if (window.msCrypto) {
+      window.msCrypto.getRandomValues(array)
+    }
+    return (window.crypto || window.msCrypto).getRandomValues
+  }
+
+  return require('get-random-values')(array)
+}
+
+const createUuid = () => {
+  // eslint-disable-next-line no-magic-numbers,require-unicode-regexp
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => {
+    const value = getRandomValues()[0] & (FIFTEEN >> (c / FOUR))
+      return (c ^ value).toString(HEX)
+    }
+  )
+}
+
+const toTitleCase = string => {
+  return `${string.slice(0, 1).toUpperCase()}${string.slice(1)}`
+}
+
+const loweredTitleCase = string => {
+  return `${string.slice(0, 1).toLowerCase()}${string.slice(1)}`
+}
+
+const getObjToArray = array => {
+  const obj = keyBy(array)
+  return {
+    ...obj,
+    toArray: () => array,
+  }
+}
+
+module.exports = {
+  loweredTitleCase,
+  toTitleCase,
+  createUuid,
+  getObjToArray,
+}

package/src/validation.js

@@ -0,0 +1,285 @@
+const isEmpty = require('lodash/isEmpty')
+const merge = require('lodash/merge')
+const isFunction = require('lodash/isFunction')
+const flatMap = require('lodash/flatMap')
+const get = require('lodash/get')
+
+const TYPE_PRIMATIVES = {
+  boolean: 'boolean',
+  string: 'string',
+  object: 'object',
+  number: 'number',
+  integer: 'integer',
+}
+
+const _trueOrError = (method, error) => value => {
+  if (method(value) === false) {
+    return error
+  }
+  return undefined
+}
+
+const _typeOrError = (type, errorMessage) => value => {
+  if (typeof value !== type) {
+    return errorMessage
+  }
+  return undefined
+}
+
+const isType = type => value => {
+  return _typeOrError(type, `Must be a ${type}`)(value)
+}
+const isNumber = isType('number')
+const isInteger = _trueOrError(Number.isInteger, 'Must be an integer')
+
+const isBoolean = isType('boolean')
+const isString = isType('string')
+const isArray = _trueOrError(v => Array.isArray(v), 'Value is not an array')
+
+const PRIMATIVE_TO_SPECIAL_TYPE_VALIDATOR = {
+  [TYPE_PRIMATIVES.boolean]: isBoolean,
+  [TYPE_PRIMATIVES.string]: isString,
+  [TYPE_PRIMATIVES.integer]: isInteger,
+  [TYPE_PRIMATIVES.number]: isNumber,
+}
+
+const arrayType = type => value => {
+  const arrayError = isArray(value)
+  if (arrayError) {
+    return arrayError
+  }
+  const validator = PRIMATIVE_TO_SPECIAL_TYPE_VALIDATOR[type] || isType(type)
+  return value.reduce((acc, v) => {
+    if (acc) {
+      return acc
+    }
+    return validator(v)
+  }, undefined)
+}
+
+const multiplePropertiesMustMatch = (getKeyA, getKeyB, errorMessage='Properties do not match') => async (_, instance) => {
+  const keyA = await getKeyA(instance)
+  const keyB = await getKeyB(instance)
+  if (keyA !== keyB) {
+    return errorMessage
+  }
+  return undefined
+}
+
+const meetsRegex =
+  (regex, flags, errorMessage = 'Format was invalid') =>
+  value => {
+    const reg = new RegExp(regex, flags)
+    return _trueOrError(v => reg.test(v), errorMessage)(value)
+  }
+
+const choices = choiceArray => value => {
+  if (Array.isArray(value)) {
+    const bad = value.find(v => !choiceArray.includes(v))
+    if (bad) {
+      return `${bad} is not a valid choice`
+    }
+  } else {
+    if (choiceArray.includes(value) === false) {
+      return `${value} is not a valid choice`
+    }
+  }
+  return undefined
+}
+
+const isDate = value => {
+  if (!value) {
+    return 'Date value is empty'
+  }
+  if (!value.toISOString) {
+    return 'Value is not a date'
+  }
+  return undefined
+}
+
+const isRequired = value => {
+  if (value === true || value === false) {
+    return undefined
+  }
+  if (isNumber(value) === undefined) {
+    return undefined
+  }
+  const empty = isEmpty(value)
+  if (empty) {
+    if (isDate(value)) {
+      return 'A value is required'
+    }
+  }
+  return undefined
+}
+
+const maxNumber = max => value => {
+  const numberError = isNumber(value)
+  if (numberError) {
+    return numberError
+  }
+  if (value > max) {
+    return `The maximum is ${max}`
+  }
+  return undefined
+}
+
+const minNumber = min => value => {
+  const numberError = isNumber(value)
+  if (numberError) {
+    return numberError
+  }
+  if (value < min) {
+    return `The minimum is ${min}`
+  }
+  return undefined
+}
+
+const maxTextLength = max => value => {
+  const stringError = isString(value)
+  if (stringError) {
+    return stringError
+  }
+  if (value.length > max) {
+    return `The maximum length is ${max}`
+  }
+  return undefined
+}
+
+const minTextLength = min => value => {
+  const stringError = isString(value)
+  if (stringError) {
+    return stringError
+  }
+  if (value.length < min) {
+    return `The minimum length is ${min}`
+  }
+  return undefined
+}
+
+const referenceTypeMatch = referencedModel => {
+  return value => {
+    // This needs to stay here, as it delays the creation long enough for
+    // self referencing types.
+    const model = isFunction(referencedModel)
+      ? referencedModel()
+      : referencedModel
+    // Assumption: By the time this is received, value === a model instance.
+    const eModel = model.getName()
+    const aModel = value.meta.getModel().getName()
+    if (eModel !== aModel) {
+      return `Model should be ${eModel} instead, recieved ${aModel}`
+    }
+    return undefined
+  }
+}
+
+const aggregateValidator = methodOrMethods => {
+  const toDo = Array.isArray(methodOrMethods)
+    ? methodOrMethods
+    : [methodOrMethods]
+
+  const _aggregativeValidator = async (...args) => {
+    const values = await Promise.all(
+      toDo.map(method => {
+        return method(...args)
+      })
+    )
+    return values.filter(x => x)
+  }
+  return _aggregativeValidator
+}
+
+const emptyValidator = () => []
+
+const _boolChoice = method => value => {
+  return value ? method : undefined
+}
+
+const CONFIG_TO_VALIDATE_METHOD = {
+  required: _boolChoice(isRequired),
+  isInteger: _boolChoice(isInteger),
+  isNumber: _boolChoice(isNumber),
+  isString: _boolChoice(isString),
+  isArray: _boolChoice(isArray),
+  isBoolean: _boolChoice(isBoolean),
+  choices,
+}
+
+const createPropertyValidator = config => {
+  const validators = [
+    ...Object.entries(config).map(([key, value]) => {
+      return (CONFIG_TO_VALIDATE_METHOD[key] || (() => undefined))(value)
+    }),
+    ...(config.validators ? config.validators : []),
+  ].filter(x => x)
+  const isRequiredValue = config.required
+    ? true
+    : validators.includes(isRequired)
+  const validator =
+    validators.length > 0 ? aggregateValidator(validators) : emptyValidator
+  const _propertyValidator = async (value, instance, instanceData={}, options) => {
+    if (!value && !isRequiredValue) {
+      return []
+    }
+    const errors = await validator(value, instance, instanceData, options)
+    return [...new Set(flatMap(errors))]
+  }
+  return _propertyValidator
+}
+
+const createModelValidator = (properties, modelValidators = []) => {
+  const _modelValidator = async (instance, options) => {
+    if (!instance) {
+      throw new Error(`Instance cannot be empty`)
+    }
+    const keysAndFunctions = Object.entries(
+      get(properties, 'functions.validators', {})
+    )
+    const instanceData = await instance.functions.toObj()
+    const propertyValidationErrors = await Promise.all(
+      keysAndFunctions.map(async ([key, validator]) => {
+        return [key, await validator(instance, instanceData, options)]
+      })
+    )
+    const modelValidationErrors = (
+      await Promise.all(
+        modelValidators.map(validator => validator(instance, instanceData, options))
+      )
+    ).filter(x => x)
+    const propertyErrors = propertyValidationErrors
+      .filter(([_, errors]) => Boolean(errors) && errors.length > 0)
+      .reduce((acc, [key, errors]) => {
+        return { ...acc, [key]: errors }
+      }, {})
+    return modelValidationErrors.length > 0
+      ? merge(propertyErrors, { overall: modelValidationErrors })
+      : propertyErrors
+  }
+  return _modelValidator
+}
+
+module.exports = {
+  isNumber,
+  isBoolean,
+  isString,
+  isInteger,
+  isType,
+  isDate,
+  isArray,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  emptyValidator,
+  createPropertyValidator,
+  createModelValidator,
+  arrayType,
+  referenceTypeMatch,
+  multiplePropertiesMustMatch,
+  TYPE_PRIMATIVES,
+}

package/test/base/index.test.js

@@ -0,0 +1,5 @@
+describe('/index.js', () => {
+  it('should load without exception', () => {
+    require('../../index')
+  })
+})