functional-models 1.0.25 → 1.1.0

package/src/validation.js

@@ -1,274 +0,0 @@
-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 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),
-  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) => {
-    if (!value && !isRequiredValue) {
-      return []
-    }
-    const errors = await validator(value, instance, instanceData)
-    return [...new Set(flatMap(errors))]
-  }
-  return _propertyValidator
-}
-
-const createModelValidator = (properties, modelValidators = []) => {
-  const _modelValidator = async instance => {
-    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)]
-      })
-    )
-    const modelValidationErrors = (
-      await Promise.all(
-        modelValidators.map(validator => validator(instance, instanceData))
-      )
-    ).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,
-  TYPE_PRIMATIVES,
-}

package/test/base/index.test.js

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

package/test/src/functions.test.js

@@ -1,45 +0,0 @@
-const assert = require('chai').assert
-const sinon = require('sinon')
-const { Function } = require('../../src/functions')
-
-describe('/src/functions.js', () => {
-  describe('#Function()', () => {
-    it('should return "Hello-world" when passed in', () => {
-      const method = sinon.stub().callsFake(input => {
-        return `${input}-world`
-      })
-      const myFunction = Function(method)
-      const wrappedObj = 'Hello'
-      const wrappedFunc = myFunction(wrappedObj)
-      const actual = wrappedFunc()
-      const expected = 'Hello-world'
-      assert.equal(actual, expected)
-    })
-    it('should call the method when Function()()() called', () => {
-      const method = sinon.stub().callsFake(input => {
-        return `${input}-world`
-      })
-      const myFunction = Function(method)
-      const wrappedObj = 'Hello'
-      const wrappedFunc = myFunction(wrappedObj)
-      const result = wrappedFunc()
-      sinon.assert.calledOnce(method)
-    })
-    it('should not call the method when Function()() called', () => {
-      const method = sinon.stub().callsFake(input => {
-        return `${input}-world`
-      })
-      const myFunction = Function(method)
-      const wrappedObj = 'Hello'
-      const wrappedFunc = myFunction(wrappedObj)
-      sinon.assert.notCalled(method)
-    })
-    it('should not call the method when Function() called', () => {
-      const method = sinon.stub().callsFake(input => {
-        return `${input}-world`
-      })
-      const myFunction = Function(method)
-      sinon.assert.notCalled(method)
-    })
-  })
-})

package/test/src/index.test.js

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

package/test/src/models.test.js

@@ -1,380 +0,0 @@
-const _ = require('lodash')
-const sinon = require('sinon')
-const assert = require('chai').assert
-const { Model } = require('../../src/models')
-const { Property, TextProperty, ReferenceProperty } = require('../../src/properties')
-
-const TEST_MODEL_1 = Model('MyModel', )
-
-describe('/src/models.js', () => {
-  describe('#Model()', () => {
-    it('should pass a functional instance to the instanceFunctions by the time the function is called by a client', () => {
-      const model = Model(
-        'ModelName',
-        {},
-        {
-          instanceFunctions: {
-            func1: instance => () => {
-              return instance.functions.func2()
-            },
-            func2: instance => () => {
-              return 'from instance func2'
-            },
-          },
-        }
-      )
-      const instance = model.create({})
-      const actual = instance.functions.func1()
-      const expected = 'from instance func2'
-      assert.deepEqual(actual, expected)
-    })
-    it('should the clients arguments before the model is passed', () => {
-      const model = Model(
-        'ModelName',
-        {},
-        {
-          modelFunctions: {
-            func1: (input, model) => {
-              return `${input} ${model.func2()}`
-            },
-            func2: model => {
-              return 'from func2'
-            },
-          },
-        }
-      )
-      const actual = model.func1('hello')
-      const expected = 'hello from func2'
-      assert.deepEqual(actual, expected)
-    })
-    it('should pass a functional model to the modelFunction by the time the function is called by a client', () => {
-      const model = Model(
-        'ModelName',
-        {},
-        {
-          modelFunctions: {
-            func1: model => {
-              return model.func2()
-            },
-            func2: model => {
-              return 'from func2'
-            },
-          },
-        }
-      )
-      const actual = model.func1()
-      const expected = 'from func2'
-      assert.deepEqual(actual, expected)
-    })
-    it('should find model.myString when modelExtension has myString function in it', () => {
-      const model = Model(
-        'ModelName',
-        {},
-        {
-          modelFunctions: {
-            myString: model => () => {
-              return 'To String'
-            },
-          },
-        }
-      )
-      assert.isFunction(model.myString)
-    })
-    describe('#getPrimaryKeyName()', () => {
-      it('should return "primaryKey" when this value is passed in as the primaryKey', () => {
-        const expected = 'primaryKey'
-        const model = Model(
-          'ModelName',
-          {},
-          {
-            primaryKey: expected,
-            modelFunctions: {
-              myString: model => () => {
-                return 'To String'
-              },
-            },
-          }
-        )
-        const actual = model.getPrimaryKeyName()
-        assert.equal(actual, expected)
-      })
-    })
-    describe('#create()', () => {
-      it('should have a meta.references.getTheReferenceId when the property has meta.getReferencedId and the key is theReference', () => {
-        const model = Model(
-          'ModelName',
-          {
-            theReference: ReferenceProperty(TEST_MODEL_1),
-          },
-        )
-        const instance = model.create({})
-        assert.isFunction(instance.meta.references.getTheReferenceId)
-      })
-      it('should have an "getId" field when no primaryKey is passed', () => {
-        const model = Model(
-          'ModelName',
-          {},
-          {
-            instanceFunctions: {
-              toString: instance => () => {
-                return 'An instance'
-              },
-            },
-          }
-        )
-        const instance = model.create({})
-        assert.isFunction(instance.getId)
-      })
-      it('should have an "getMyPrimaryKeyId" field when "myPrimaryKeyId" is passed as the "primaryKey" is passed', () => {
-        const model = Model(
-          'ModelName',
-          {},
-          {
-            primaryKey: 'myPrimaryKeyId',
-            instanceFunctions: {
-              toString: instance => () => {
-                return 'An instance'
-              },
-            },
-          }
-        )
-        const instance = model.create({})
-        assert.isFunction(instance.getMyPrimaryKeyId)
-      })
-      it('should find instance.functions.toString when in instanceFunctions', () => {
-        const model = Model(
-          'ModelName',
-          {},
-          {
-            instanceFunctions: {
-              toString: instance => () => {
-                return 'An instance'
-              },
-            },
-          }
-        )
-        const instance = model.create({})
-        assert.isFunction(instance.functions.toString)
-      })
-      it('should call the instanceCreatedCallback function when create() is called', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const callback = sinon.stub()
-        const model = Model('name', input, {
-          instanceCreatedCallback: callback,
-        })
-        model.create({ myProperty: 'value' })
-        sinon.assert.calledOnce(callback)
-      })
-      it('should not throw an exception if nothing is passed into function', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const model = Model('name', input)
-        assert.doesNotThrow(() => {
-          model.create()
-        })
-      })
-      it('should return an object that contains meta.getModel().getProperties().myProperty', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: 'value' })
-        const actual = instance.meta.getModel().getProperties().myProperty
-        assert.isOk(actual)
-      })
-      it('should combine the meta within the instance values', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({
-          myProperty: 'value',
-          meta: { random: () => 'random' },
-        })
-        const actual = instance.meta.random()
-        const expected = 'random'
-        assert.equal(actual, expected)
-      })
-      it('should flow through the additional special functions within the keyValues', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-          functions: {
-            custom: () => 'works',
-          },
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: 'value' })
-        const actual = instance.functions.custom()
-        const expected = 'works'
-        assert.equal(actual, expected)
-      })
-      it('should return an object that contains meta.getModel().getName()===test-the-name', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const model = Model('test-the-name', input)
-        const instance = model.create({ myProperty: 'value' })
-        const actual = instance.meta.getModel().getName()
-        const expected = 'test-the-name'
-        assert.deepEqual(actual, expected)
-      })
-      it('should return an object that contains meta.getModel().getProperties().myProperty', () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: 'value' })
-        const actual = instance.meta.getModel().getProperties().myProperty
-        assert.isOk(actual)
-      })
-      it('should use the value passed in when Property.defaultValue and Property.value are not set', async () => {
-        const input = {
-          myProperty: Property({ required: true }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: 'passed-in' })
-        const actual = await instance.getMyProperty()
-        const expected = 'passed-in'
-        assert.deepEqual(actual, expected)
-      })
-      it('should use the value for Property.value when even if Property.defaultValue is set and a value is passed in', async () => {
-        const input = {
-          myProperty: Property({
-            value: 'value',
-            defaultValue: 'default-value',
-          }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: 'passed-in' })
-        const actual = await instance.getMyProperty()
-        const expected = 'value'
-        assert.deepEqual(actual, expected)
-      })
-      it('should use the value for Property.value when even if Property.defaultValue is not set and a value is passed in', async () => {
-        const input = {
-          myProperty: Property({ value: 'value' }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: 'passed-in' })
-        const actual = await instance.getMyProperty()
-        const expected = 'value'
-        assert.deepEqual(actual, expected)
-      })
-      it('should use the value for Property.defaultValue when Property.value is not set and no value is passed in', async () => {
-        const input = {
-          myProperty: Property({ defaultValue: 'defaultValue' }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({})
-        const actual = await instance.getMyProperty()
-        const expected = 'defaultValue'
-        assert.deepEqual(actual, expected)
-      })
-      it('should use the value for Property.defaultValue when Property.value is not set and null is passed as a value', async () => {
-        const input = {
-          myProperty: Property({ defaultValue: 'defaultValue' }),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ myProperty: null })
-        const actual = await instance.getMyProperty()
-        const expected = 'defaultValue'
-        assert.deepEqual(actual, expected)
-      })
-      it('should return a model with getId and getType for the provided valid keyToProperty', () => {
-        const input = {
-          id: Property({ required: true }),
-          type: Property(),
-        }
-        const model = Model('name', input)
-        const actual = model.create({ id: 'my-id', type: 'my-type' })
-        assert.isOk(actual.getId)
-        assert.isOk(actual.getType)
-      })
-      it('should return a model where validate returns one error for id', async () => {
-        const input = {
-          id: Property({ required: true }),
-          type: Property(),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ type: 'my-type' })
-        const actual = await instance.functions.validate()
-        const expected = 1
-        assert.equal(Object.values(actual).length, expected)
-      })
-      it('should return a model where validate returns one error for the missing text property', async () => {
-        const input = {
-          id: Property({ required: true }),
-          text: TextProperty({required: true}),
-        }
-        const model = Model('name', input)
-        const instance = model.create({ id: 'my-id' })
-        const actual = await instance.functions.validate()
-        const expected = 1
-        assert.equal(Object.values(actual).length, expected)
-      })
-    })
-    it('should return an object with a function "create" when called once with valid data', () => {
-      const actual = Model('name', {})
-      assert.isFunction(actual.create)
-    })
-    it('should throw an exception if a key "model" is passed in', () => {
-      assert.throws(() => {
-        Model('name', { model: 'weeee' }).create()
-      })
-    })
-    describe('#meta.references.getMyReferencedId()', () => {
-      it('should return the id from the ReferenceProperty', () => {
-        const model = Model(
-          'ModelName',
-          {
-            myReference: ReferenceProperty(TEST_MODEL_1),
-          },
-        )
-        const instance = model.create({ myReference: 'unit-test-id' })
-        const actual = instance.meta.references.getMyReferenceId()
-        const expected = 'unit-test-id'
-        assert.deepEqual(actual, expected)
-      })
-    })
-    describe('#functions.getPrimaryKey()', () => {
-      it('should return the id field when no primaryKey is passed', async () => {
-        const model = Model(
-          'ModelName',
-          {},
-          {
-            instanceFunctions: {
-              toString: instance => () => {
-                return 'An instance'
-              },
-            },
-          }
-        )
-        const expected = 'my-primary-key'
-        const instance = model.create({ id: expected })
-        const actual = await instance.functions.getPrimaryKey()
-        assert.equal(actual, expected)
-      })
-      it('should return the primaryKey field when "primaryKey" is passed as primaryKey', async () => {
-        const model = Model(
-          'ModelName',
-          {},
-          {
-            primaryKey: 'primaryKey',
-            instanceFunctions: {
-              toString: instance => () => {
-                return 'An instance'
-              },
-            },
-          }
-        )
-        const expected = 'my-primary-key'
-        const instance = model.create({ primaryKey: expected })
-        const actual = await instance.functions.getPrimaryKey()
-        assert.equal(actual, expected)
-      })
-    })
-  })
-})