functional-models 1.0.1 → 1.0.5

package/test/src/fields.test.js

@@ -0,0 +1,160 @@
+const assert = require('chai').assert
+const {
+  uniqueId,
+  field,
+  dateField,
+  referenceField,
+} = require('../../src/fields')
+const { createModel } = require('../../src/models')
+
+describe('/src/fields.js', () => {
+  describe('#field()', () => {
+    it('should throw an exception if config.valueSelector is not a function but is set', () => {
+      assert.throws(() => {
+        field({ valueSelector: 'blah' })
+      })
+    })
+    it('should not throw an exception if config.valueSelector is a function', () => {
+      assert.doesNotThrow(() => {
+        field({ valueSelector: () => ({}) })
+      })
+    })
+    describe('#createGetter()', () => {
+      it('should return a function even if config.value is set to a value', () => {
+        const instance = field({ value: 'my-value' })
+        const actual = instance.createGetter('not-my-value')
+        assert.isFunction(actual)
+      })
+      it('should return the value passed into config.value regardless of what is passed into the createGetter', async () => {
+        const instance = field({ value: 'my-value' })
+        const actual = await instance.createGetter('not-my-value')()
+        const expected = 'my-value'
+        assert.deepEqual(actual, expected)
+      })
+      it('should return the value passed into createGetter when config.value is not set', async () => {
+        const instance = field()
+        const actual = await instance.createGetter('my-value')()
+        const expected = 'my-value'
+        assert.deepEqual(actual, expected)
+      })
+      it('should return the value of the function passed into createGetter when config.value is not set', async () => {
+        const instance = field()
+        const actual = await instance.createGetter(() => 'my-value')()
+        const expected = 'my-value'
+        assert.deepEqual(actual, expected)
+      })
+    })
+  })
+  describe('#uniqueId()', () => {
+    describe('#createGetter()', () => {
+      it('should call createUuid only once even if called twice', async () => {
+        const uniqueField = uniqueId({})
+        const getter = uniqueField.createGetter()
+        const first = await getter()
+        const second = await getter()
+        assert.deepEqual(first, second)
+      })
+      it('should use the uuid passed in', async () => {
+        const uniqueField = uniqueId({})
+        const getter = uniqueField.createGetter('my-uuid')
+        const actual = await getter()
+        const expected = 'my-uuid'
+        assert.deepEqual(actual, expected)
+      })
+    })
+  })
+  describe('#dateField()', () => {
+    it('should create a new date once when config.autoNow=true and called multiple times', async () => {
+      const proto = dateField({ autoNow: true })
+      const instance = proto.createGetter()
+      const first = await instance()
+      const second = await instance()
+      const third = await instance()
+      assert.deepEqual(first, second)
+      assert.deepEqual(first, third)
+    })
+    it('should use the date passed in', async () => {
+      const proto = dateField({ autoNow: true })
+      const date = new Date()
+      const instance = proto.createGetter(date)
+      const actual = await instance()
+      const expected = date
+      assert.deepEqual(actual, expected)
+    })
+  })
+
+  describe('#referenceField()', () => {
+    describe('#createGetter()', () => {
+      it('should return "obj-id" when no fetcher is used', async () => {
+        const input = ['obj-id']
+        const actual = await referenceField({}).createGetter(...input)()
+        const expected = 'obj-id'
+        assert.equal(actual, expected)
+      })
+      it('should allow null as the input', async () => {
+        const input = [null]
+        const actual = await referenceField({}).createGetter(...input)()
+        const expected = null
+        assert.equal(actual, expected)
+      })
+      it('should return "obj-id" from {}.id when no fetcher is used', async () => {
+        const input = [{ id: 'obj-id' }]
+        const actual = await referenceField({}).createGetter(...input)()
+        const expected = 'obj-id'
+        assert.equal(actual, expected)
+      })
+      it('should return prop: "switch-a-roo" when switch-a-roo fetcher is used', async () => {
+        const input = ['obj-id']
+        const actual = await referenceField({
+          fetcher: () => ({ id: 'obj-id', prop: 'switch-a-roo' }),
+        }).createGetter(...input)()
+        const expected = 'switch-a-roo'
+        assert.deepEqual(actual.prop, expected)
+      })
+      it('should combine functions when switch-a-roo fetcher is used', async () => {
+        const input = ['obj-id']
+        const instance = await referenceField({
+          fetcher: () => ({
+            id: 'obj-id',
+            prop: 'switch-a-roo',
+            functions: { myfunc: 'ok' },
+          }),
+        }).createGetter(...input)()
+        const actual = instance.functions.myfunc
+        const expected = 'ok'
+        assert.deepEqual(actual, expected)
+      })
+      it('should take the smartObject as a value', async () => {
+        const proto = createModel({
+          id: uniqueId({ value: 'obj-id' }),
+        })
+        const input = [proto({ id: 'obj-id' })]
+        const instance = await referenceField({}).createGetter(...input)()
+        const actual = await instance.getId()
+        const expected = 'obj-id'
+        assert.deepEqual(actual, expected)
+      })
+      describe('#functions.toJson()', () => {
+        it('should use the getId of the smartObject passed in when toJson is called', async () => {
+          const proto = createModel({
+            id: uniqueId({ value: 'obj-id' }),
+          })
+          const input = [proto({ id: 'obj-id' })]
+          const instance = await referenceField({}).createGetter(...input)()
+          const actual = await instance.functions.toJson()
+          const expected = 'obj-id'
+          assert.deepEqual(actual, expected)
+        })
+        it('should return "obj-id" when switch-a-roo fetcher is used and toJson is called', async () => {
+          const input = ['obj-id']
+          const instance = await referenceField({
+            fetcher: () => ({ id: 'obj-id', prop: 'switch-a-roo' }),
+          }).createGetter(...input)()
+          const actual = await instance.functions.toJson()
+          const expected = 'obj-id'
+          assert.deepEqual(actual, expected)
+        })
+      })
+    })
+  })
+})

package/test/src/lazy.test.js

@@ -1,25 +1,15 @@
 const assert = require('chai').assert
-const { lazyProperty } = require('../../src/lazy')
+const sinon = require('sinon')
+const { lazyValue } = require('../../src/lazy')
 
 describe('/src/lazy.js', () => {
-  describe('#lazyProperty()', () => {
-    it('should call the selector that is passed in', async () => {
-      const inputs = [
-        'lazy',
-        () => 'hello world',
-        { selector: value => value.slice(6) },
-      ]
-      const obj = lazyProperty(...inputs)
-      const actual = await obj.getLazy()
-      const expected = 'world'
-      assert.deepEqual(actual, expected)
-    })
-    it('should return the lazy value that is passed in', async () => {
-      const inputs = ['lazy', () => 'hello world']
-      const obj = lazyProperty(...inputs)
-      const actual = await obj.getLazy()
-      const expected = 'hello world'
-      assert.deepEqual(actual, expected)
+  describe('#lazyValue()', () => {
+    it('should only call the method passed in once even after two calls', async () => {
+      const method = sinon.stub().returns('hello-world')
+      const instance = lazyValue(method)
+      await instance()
+      await instance()
+      sinon.assert.calledOnce(method)
     })
   })
 })

package/test/src/models.test.js

@@ -0,0 +1,97 @@
+const assert = require('chai').assert
+const { createModel } = require('../../src/models')
+const { field } = require('../../src/fields')
+
+describe('/src/models.js', () => {
+  describe('#createModel()', () => {
+    it('should return a function when called once with valid data', () => {
+      const actual = createModel({})
+      const expected = 'function'
+      assert.isFunction(actual)
+    })
+    describe('#()', () => {
+      it('should use the value passed in when field.defaultValue and field.value are not set', async () => {
+        const input = {
+          myField: field({ required: true }),
+        }
+        const model = createModel(input)
+        const instance = model({ myField: 'passed-in' })
+        const actual = await instance.getMyField()
+        const expected = 'passed-in'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for field.value when even if field.defaultValue is set and a value is passed in', async () => {
+        const input = {
+          myField: field({ value: 'value', defaultValue: 'default-value' }),
+        }
+        const model = createModel(input)
+        const instance = model({ myField: 'passed-in' })
+        const actual = await instance.getMyField()
+        const expected = 'value'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for field.value when even if field.defaultValue is not set and a value is passed in', async () => {
+        const input = {
+          myField: field({ value: 'value' }),
+        }
+        const model = createModel(input)
+        const instance = model({ myField: 'passed-in' })
+        const actual = await instance.getMyField()
+        const expected = 'value'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for field.defaultValue when field.value is not set and no value is passed in', async () => {
+        const input = {
+          myField: field({ defaultValue: 'defaultValue' }),
+        }
+        const model = createModel(input)
+        const instance = model({})
+        const actual = await instance.getMyField()
+        const expected = 'defaultValue'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for field.defaultValue when field.value is not set and null is passed as a value', async () => {
+        const input = {
+          myField: field({ defaultValue: 'defaultValue' }),
+        }
+        const model = createModel(input)
+        const instance = model({ myField: null })
+        const actual = await instance.getMyField()
+        const expected = 'defaultValue'
+        assert.deepEqual(actual, expected)
+      })
+      it('should return a model with getId and getType for the provided valid keyToField', () => {
+        const input = {
+          id: field({ required: true }),
+          type: field(),
+        }
+        const model = createModel(input)
+        const actual = model({ id: 'my-id', type: 'my-type' })
+        console.log(actual)
+        assert.isOk(actual.getId)
+        assert.isOk(actual.getType)
+      })
+      it('should return a model where validate returns one error for id', async () => {
+        const input = {
+          id: field({ required: true }),
+          type: field(),
+        }
+        const model = createModel(input)
+        const instance = model({ type: 'my-type' })
+        const actual = await instance.functions.validate.model()
+        const expected = 1
+        console.log(actual)
+        assert.equal(Object.values(actual).length, expected)
+      })
+    })
+    it('should return a function when called once with valid data', () => {
+      const actual = createModel({})
+      assert.isFunction(actual)
+    })
+    it('should throw an exception if a key "model" is passed in', () => {
+      assert.throws(() => {
+        createModel({ model: 'weeee' })
+      })
+    })
+  })
+})

package/test/src/utils.test.js

@@ -1,18 +1,9 @@
 const assert = require('chai').assert
 const sinon = require('sinon')
 const proxyquire = require('proxyquire')
-const { loweredTitleCase, createUuid, lazyValue } = require('../../src/utils')
+const { loweredTitleCase, createUuid } = require('../../src/utils')
 
 describe('/src/utils.js', () => {
-  describe('#lazyValue()', () => {
-    it('should only call the method passed in once even after two calls', async () => {
-      const method = sinon.stub().returns('hello-world')
-      const instance = lazyValue(method)
-      await instance()
-      await instance()
-      sinon.assert.calledOnce(method)
-    })
-  })
   describe('#loweredTitleCase()', () => {
     it('should turn TitleCase into titleCase', () => {
       const actual = loweredTitleCase('TitleCase')

package/test/src/validation.test.js

@@ -0,0 +1,318 @@
+const assert = require('chai').assert
+const sinon = require('sinon')
+const {
+  isNumber,
+  isBoolean,
+  isInteger,
+  isString,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  emptyValidator,
+  createModelValidator,
+  createFieldValidator,
+} = require('../../src/validation')
+
+describe('/src/validation.js', () => {
+  describe('#isNumber()', () => {
+    it('should return an error when empty is passed', () => {
+      const actual = isNumber(null)
+      assert.isOk(actual)
+    })
+    it('should return an error when "asdf" is passed', () => {
+      const actual = isNumber('asdf')
+      assert.isOk(actual)
+    })
+    it('should return undefined when 1 is passed', () => {
+      const actual = isNumber(1)
+      assert.isUndefined(actual)
+    })
+    it('should return error when "1" is passed', () => {
+      const actual = isNumber('1')
+      assert.isOk(actual)
+    })
+  })
+  describe('#isString()', () => {
+    it('should return undefined when "1" is passed', () => {
+      const actual = isString('1')
+      assert.isUndefined(actual)
+    })
+    it('should return error when 1 is passed', () => {
+      const actual = isString(1)
+      assert.isOk(actual)
+    })
+  })
+  describe('#isRequired()', () => {
+    it('should return undefined when 1 is passed', () => {
+      const actual = isRequired(1)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when 0 is passed', () => {
+      const actual = isRequired(0)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when "something" is passed', () => {
+      const actual = isRequired('something')
+      assert.isUndefined(actual)
+    })
+    it('should return error when null is passed', () => {
+      const actual = isRequired(null)
+      assert.isOk(actual)
+    })
+    it('should return error when undefined is passed', () => {
+      const actual = isRequired(undefined)
+      assert.isOk(actual)
+    })
+    it('should return undefined when false is passed', () => {
+      const actual = isRequired(false)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when true is passed', () => {
+      const actual = isRequired(true)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#isBoolean()', () => {
+    it('should return error when "true" is passed"', () => {
+      const actual = isBoolean('true')
+      assert.isOk(actual)
+    })
+    it('should return an error when "false" is passed', () => {
+      const actual = isBoolean('false')
+      assert.isOk(actual)
+    })
+    it('should return undefined when true is passed"', () => {
+      const actual = isBoolean(true)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when false is passed', () => {
+      const actual = isBoolean(false)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#maxNumber()', () => {
+    it('should return error if max=5 and value="hello world"', () => {
+      const actual = maxNumber(5)('hello world')
+      assert.isOk(actual)
+    })
+    it('should return error if max=5 and value=6', () => {
+      const actual = maxNumber(5)(6)
+      assert.isOk(actual)
+    })
+    it('should return undefined if max=5 and value=5', () => {
+      const actual = maxNumber(5)(5)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if max=5 and value=4', () => {
+      const actual = maxNumber(5)(4)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#minNumber()', () => {
+    it('should return error if min=5 and value="hello world"', () => {
+      const actual = minNumber(5)('hello world')
+      assert.isOk(actual)
+    })
+    it('should return error if min=5 and value=4', () => {
+      const actual = minNumber(5)(4)
+      assert.isOk(actual)
+    })
+    it('should return undefined if min=5 and value=4', () => {
+      const actual = minNumber(5)(5)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if min=5 and value=6', () => {
+      const actual = minNumber(5)(6)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#choices()', () => {
+    it('should return an error if choices are [1,2,3] and value is 4', () => {
+      const actual = choices([1, 2, 3])(4)
+      assert.isOk(actual)
+    })
+    it('should return undefined if choices are [1,2,3] and value is 1', () => {
+      const actual = choices([1, 2, 3])(1)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#minTextLength()', () => {
+    it('should return error if min=5 and value=5', () => {
+      const actual = minTextLength(5)(5)
+      assert.isOk(actual)
+    })
+    it('should return error if length=5 and value="asdf"', () => {
+      const actual = minTextLength(5)('asdf')
+      assert.isOk(actual)
+    })
+    it('should return undefined if length=5 and value="hello"', () => {
+      const actual = minTextLength(5)('hello')
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if length=5 and value="hello world"', () => {
+      const actual = minTextLength(5)('hello world')
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#maxTextLength()', () => {
+    it('should return error if max=5 and value=5', () => {
+      const actual = maxTextLength(5)(5)
+      assert.isOk(actual)
+    })
+    it('should return error if length=5 and value="hello world"', () => {
+      const actual = maxTextLength(5)('hello world')
+      assert.isOk(actual)
+    })
+    it('should return undefined if length=5 and value="hello"', () => {
+      const actual = maxTextLength(5)('hello')
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if length=5 and value="asdf"', () => {
+      const actual = maxTextLength(5)('asdf')
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#meetsRegex()', () => {
+    it('should return an error with regex=/asdf/ flags="g" and value="hello world"', () => {
+      const actual = meetsRegex(/asdf/, 'g')('hello world')
+      assert.isOk(actual)
+    })
+    it('should return undefined with regex=/asdf/ flags="g" and value="hello asdf world"', () => {
+      const actual = meetsRegex(/asdf/, 'g')('asdf')
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#aggregateValidator()', () => {
+    it('should return two errors when two validators are passed, and the value fails both', async () => {
+      const validators = [minTextLength(10), isNumber]
+      const value = 'asdf'
+      const actual = (await aggregateValidator(validators)('asdf')).length
+      const expected = 2
+      assert.equal(actual, expected)
+    })
+    it('should return one error when one validator is passed, and the value fails', async () => {
+      const validators = minTextLength(10)
+      const value = 'asdf'
+      const actual = (await aggregateValidator(validators)('asdf')).length
+      const expected = 1
+      assert.equal(actual, expected)
+    })
+  })
+  describe('#emptyValidator()', () => {
+    it('should return an empty array with a value of 1', () => {
+      const actual = emptyValidator(1).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of "1"', () => {
+      const actual = emptyValidator('1').length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of true', () => {
+      const actual = emptyValidator(true).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of false', () => {
+      const actual = emptyValidator(false).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of undefined', () => {
+      const actual = emptyValidator(undefined).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+  })
+  describe('#isInteger()', () => {
+    it('should return an error with a value of "1"', () => {
+      const actual = isInteger('1')
+      assert.isOk(actual)
+    })
+    it('should return undefined with a value of 1', () => {
+      const actual = isInteger(1)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#createModelValidator()', () => {
+    it('should use both functions.validate for two objects', async () => {
+      const fields = {
+        functions: {
+          validate: {
+            id: sinon.stub().returns(undefined),
+            type: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(fields)
+      await validator()
+      sinon.assert.calledOnce(fields.functions.validate.id)
+      sinon.assert.calledOnce(fields.functions.validate.type)
+    })
+    it('should combine results for both functions.validate for two objects that error', async () => {
+      const fields = {
+        functions: {
+          validate: {
+            id: sinon.stub().returns('error1'),
+            type: sinon.stub().returns('error2'),
+          },
+        },
+      }
+      const validator = createModelValidator(fields)
+      const actual = await validator()
+      const expected = {
+        id: 'error1',
+        type: 'error2',
+      }
+      assert.deepEqual(actual, expected)
+    })
+    it('should take the error of the one of two functions', async () => {
+      const fields = {
+        functions: {
+          validate: {
+            id: sinon.stub().returns(undefined),
+            type: sinon.stub().returns('error2'),
+          },
+        },
+      }
+      const validator = createModelValidator(fields)
+      const actual = await validator()
+      const expected = {
+        type: 'error2',
+      }
+      assert.deepEqual(actual, expected)
+    })
+  })
+  describe('#createFieldValidator()', () => {
+    it('should not include isRequired if required=false, returning []', async () => {
+      const validator = createFieldValidator({ required: false })
+      const actual = await validator(null)
+      const expected = []
+      assert.deepEqual(actual, expected)
+    })
+    it('should return [] if no configs are provided', async () => {
+      const validator = createFieldValidator({})
+      const actual = await validator(null)
+      const expected = []
+      assert.deepEqual(actual, expected)
+    })
+    it('should use isRequired if required=false, returning one error', async () => {
+      const validator = createFieldValidator({ required: true })
+      const actual = await validator(null)
+      const expected = 1
+      assert.equal(actual.length, expected)
+    })
+    it('should use validators.isRequired returning one error', async () => {
+      const validator = createFieldValidator({ validators: [isRequired] })
+      const actual = await validator(null)
+      const expected = 1
+      assert.equal(actual.length, expected)
+    })
+  })
+})

package/src/dates.js

@@ -1,13 +0,0 @@
-const { property } = require('./properties')
-
-const _autonowDate = ({ key }) => (date = null, ...args) => {
-  const theDate = date ? date : new Date()
-  return property(key, theDate, ...args)
-}
-const lastModifiedProperty = _autonowDate({ key: 'lastModified' })
-const lastUpdatedProperty = _autonowDate({ key: 'lastUpdated' })
-
-module.exports = {
-  lastModifiedProperty,
-  lastUpdatedProperty,
-}

package/src/objects.js

@@ -1,23 +0,0 @@
-const { toJson } = require('./serialization')
-
-const smartObject = (
-  internals,
-  { metaProperties = {}, functions = {} } = {}
-) => {
-  const realInternals = Array.isArray(internals)
-    ? internals.reduce((acc, obj) => ({ ...acc, ...obj }), {})
-    : internals
-
-  return {
-    ...(metaProperties ? { meta: { ...metaProperties } } : {}),
-    ...realInternals,
-    functions: {
-      ...functions,
-      toJson: toJson(realInternals),
-    },
-  }
-}
-
-module.exports = {
-  smartObject,
-}