functional-models 1.0.6 → 1.0.10

package/README.md

@@ -10,29 +10,36 @@ This library empowers the creation of pure JavaScript function based models that
 ## Example Usage
 
     const {
-      smartObject,
-      property,
-      typed,
+      field,
+      constantValueField,
+      textField,
+      dateField,
+      integerField,
       uniqueId,
+      createModel,
+      validation,
     }= require('functional-models')
 
-    const Truck = ({ id, make, model, color, year }) => smartObject([
-      uniqueId(id),
-      typed('truck'),
-      property('make', make),
-      property('model', model),
-      property('color', color),
-      property('year', year),
-    ])
+    const Truck = createModel({
+      type: constantValueField('truck'),
+      id: uniqueId({required: true}),
+      make: textField({ maxLength: 20, minLength: 3, required: true}),
+      model: textField({ maxLength: 20, minLength: 3, required: true}),
+      color: textField({ maxLength: 10, minLength: 3, validators: [
+        validation.meetsRegex(/Red/),
+      ]}),
+      year: integerField({ maxValue: 2500, minValue: 1900}),
+      lastModified: dateField({ autoNow: true}),
+    })
 
 
     const myTruck = Truck({ make: 'Ford', model: 'F-150', color: 'White', year: 2013})
 
-    console.log(myTruck.getId())     // a random uuid
-    console.log(myTruck.getMake())   // 'Ford'
-    console.log(myTruck.getModel())  // 'F-150'
-    console.log(myTruck.getColor())  // 'White'
-    console.log(myTruck.getYear())   // 2013
+    console.log(await myTruck.getId())     // a random uuid
+    console.log(await myTruck.getMake())   // 'Ford'
+    console.log(await myTruck.getModel())  // 'F-150'
+    console.log(await myTruck.getColor())  // 'White'
+    console.log(await myTruck.getYear())   // 2013
 
     const asJson = await myTruck.functions.toJson()
     console.log(asJson)
@@ -47,8 +54,19 @@ This library empowers the creation of pure JavaScript function based models that
     */
 
     const sameTruck = Truck(asJson)
-    console.log(sameTruck.getId())     // same uuid as above
-    console.log(sameTruck.getMake())   // 'Ford'
-    console.log(sameTruck.getModel())  // 'F-150'
-    console.log(sameTruck.getColor())  // 'White'
-    console.log(sameTruck.getYear())   // 2013
+    console.log(await sameTruck.getId())     // same uuid as above
+    console.log(await sameTruck.getMake())   // 'Ford'
+    console.log(await sameTruck.getModel())  // 'F-150'
+    console.log(await sameTruck.getColor())  // 'White'
+    console.log(await sameTruck.getYear())   // 2013
+
+    // Validation
+    const errors = await sameTruck.functions.validate.model() // {}
+    
+    const newTruck = Truck({ make: 'Ford', model: 'F-150', color: 'White', year: 20130})
+    const errors2 = await newTruck.functions.validate.model()
+    console.log(errors2)
+    // {"year": 'Value is too long'}
+
+
+

package/features/arrayFields.feature

@@ -36,3 +36,17 @@ Feature: Array Fields
     Then the getArrayField field is called on the model
     Then functions.validate is called
     Then an array of 0 errors is shown
+
+  Scenario: A model that uses the arrayField with the choice validator should pass validation with no errors.
+    Given ArrayModel4 model is used
+    When ArrayModelData5 data is inserted
+    Then the getArrayField field is called on the model
+    Then functions.validate is called
+    Then an array of 0 errors is shown
+
+  Scenario: A model that uses the arrayField with the choice validator should fail validation when one value is outside the choices
+    Given ArrayModel4 model is used
+    When ArrayModelData6 data is inserted
+    Then the getArrayField field is called on the model
+    Then functions.validate is called
+    Then an array of 1 errors is shown

package/features/stepDefinitions/steps.js

@@ -4,23 +4,29 @@ const { Given, When, Then } = require('@cucumber/cucumber')
 const { createModel, field, arrayField, validation } = require('../../index')
 
 const MODEL_DEFINITIONS = {
-  TestModel1: createModel({
+  TestModel1: createModel("TestModel1", {
     name: field({ required: true }),
     type: field({ required: true, isString: true }),
     flag: field({ required: true, isNumber: true }),
   }),
-  ArrayModel1: createModel({
+  ArrayModel1: createModel("ArrayModel1", {
     arrayField: field({
       isArray: true,
       validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],
     }),
   }),
-  ArrayModel2: createModel({
+  ArrayModel2: createModel("ArrayModel2", {
     arrayField: field({ isArray: true }),
   }),
-  ArrayModel3: createModel({
+  ArrayModel3: createModel("ArrayModel3", {
     arrayField: arrayField({}),
   }),
+  ArrayModel4: createModel("ArrayModel4", {
+    arrayField: arrayField({
+      choices: [4, 5, 6],
+      validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],
+    }),
+  }),
 }
 
 const MODEL_INPUT_VALUES = {
@@ -46,6 +52,12 @@ const MODEL_INPUT_VALUES = {
   ArrayModelData4: {
     arrayField: ['a-string', 1, {}, true],
   },
+  ArrayModelData5: {
+    arrayField: [4, 5, 5, 5, 6],
+  },
+  ArrayModelData6: {
+    arrayField: [4, 5, 5, 5, 6, 1],
+  },
 }
 
 const EXPECTED_FIELDS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functional-models",
-  "version": "1.0.6",
+  "version": "1.0.10",
   "description": "A library for creating JavaScript function based models.",
   "main": "index.js",
   "scripts": {
@@ -29,6 +29,7 @@
   "nyc": {
     "all": true,
     "exclude": [
+      "coverage/",
       "features/stepDefinitions/*",
       "test/*"
     ]

package/src/fields.js

@@ -1,8 +1,28 @@
 const identity = require('lodash/identity')
-const { createFieldValidator } = require('./validation')
+const merge = require('lodash/merge')
+const {
+  createFieldValidator,
+  emptyValidator,
+  maxTextLength,
+  minTextLength,
+  minNumber,
+  maxNumber,
+  isType,
+  meetsRegex,
+} = require('./validation')
 const { createUuid } = require('./utils')
 const { lazyValue } = require('./lazy')
 
+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 field = (config = {}) => {
   const value = config.value || undefined
   const defaultValue = config.defaultValue || undefined
@@ -33,9 +53,11 @@ const field = (config = {}) => {
       }
     },
     getValidator: valueGetter => {
-      return async () => {
-        return createFieldValidator(config)(await valueGetter())
+      const validator = createFieldValidator(config)
+      const _fieldValidatorWrapper = async () => {
+        return validator(await valueGetter())
       }
+      return _fieldValidatorWrapper
     },
   }
 }
@@ -81,7 +103,7 @@ const referenceField = config => {
           ...objToUse,
           functions: {
             ...(objToUse.functions ? objToUse.functions : {}),
-            toJson: _getId,
+            toObj: _getId,
           },
         }
       }
@@ -105,10 +127,82 @@ const arrayField = (config = {}) =>
     isArray: true,
   })
 
+const objectField = (config = {}) =>
+  field(
+    merge(config, {
+      validators: [isType('object')],
+    })
+  )
+
+const textField = (config = {}) =>
+  field(
+    merge(config, {
+      isString: true,
+      validators: [
+        _getValidatorFromConfigElseEmpty(config, 'maxLength', value =>
+          maxTextLength(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'minLength', value =>
+          minTextLength(value)
+        ),
+      ],
+    })
+  )
+
+const integerField = (config = {}) =>
+  field(
+    merge(config, {
+      isInteger: true,
+      validators: [
+        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
+          maxNumber(value)
+        ),
+      ],
+    })
+  )
+
+const numberField = (config = {}) =>
+  field(
+    merge(config, {
+      isNumber: true,
+      validators: [
+        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
+          maxNumber(value)
+        ),
+      ],
+    })
+  )
+
+const constantValueField = (value, config = {}) =>
+  textField(
+    merge(config, {
+      value,
+    })
+  )
+
+const emailField = (config = {}) =>
+  textField(
+    merge(config, {
+      validators: [meetsRegex(EMAIL_REGEX)],
+    })
+  )
+
 module.exports = {
   field,
   uniqueId,
   dateField,
   arrayField,
   referenceField,
+  integerField,
+  textField,
+  constantValueField,
+  numberField,
+  objectField,
+  emailField,
 }

package/src/models.js

@@ -1,29 +1,36 @@
 const merge = require('lodash/merge')
-const get = require('lodash/get')
-const { toJson } = require('./serialization')
+const pickBy = require('lodash/pickBy')
+const { toObj } = require('./serialization')
 const { createPropertyTitle } = require('./utils')
 const { createModelValidator } = require('./validation')
 
-const SYSTEM_KEYS = ['meta', 'functions']
-
+const MODEL_DEF_KEYS = ['meta', 'functions']
 const PROTECTED_KEYS = ['model']
 
-const createModel = keyToField => {
+const createModel = (modelName, keyToField) => {
   PROTECTED_KEYS.forEach(key => {
     if (key in keyToField) {
       throw new Error(`Cannot use ${key}. This is a protected value.`)
     }
   })
-  const systemProperties = SYSTEM_KEYS.reduce((acc, key) => {
-    const value = get(keyToField, key, {})
-    return { ...acc, [key]: value }
+  const fieldProperties = Object.entries(keyToField).filter(
+    ([key, _]) => !(key in MODEL_DEF_KEYS)
+  )
+  const fields = fieldProperties.reduce((acc, [key, field]) => {
+    return { ...acc, [key]: field }
   }, {})
-  const nonSystemProperties = Object.entries(keyToField).filter(
-    ([key, _]) => !(key in SYSTEM_KEYS)
+  const modelDefProperties = merge(
+    pickBy(keyToField, (value, key) => MODEL_DEF_KEYS.includes(key)),
+    {
+      meta: {
+        fields,
+        modelName,
+      },
+    }
   )
 
-  return instanceValues => {
-    const loadedInternals = nonSystemProperties.reduce((acc, [key, field]) => {
+  return (instanceValues = {}) => {
+    const loadedInternals = fieldProperties.reduce((acc, [key, field]) => {
       const fieldGetter = field.createGetter(instanceValues[key])
       const fieldValidator = field.getValidator(fieldGetter)
       const getFieldKey = createPropertyTitle(key)
@@ -37,16 +44,15 @@ const createModel = keyToField => {
       }
       return merge(acc, fleshedOutField)
     }, {})
-    const allUserData = merge(systemProperties, loadedInternals)
-    const internalFunctions = {
+    const frameworkProperties = {
       functions: {
-        toJson: toJson(loadedInternals),
+        toObj: toObj(loadedInternals),
         validate: {
           model: createModelValidator(loadedInternals),
         },
       },
     }
-    return merge(allUserData, internalFunctions)
+    return merge(loadedInternals, modelDefProperties, frameworkProperties)
   }
 }
 

package/src/serialization.js

@@ -12,8 +12,8 @@ const _getValue = async value => {
     return _getValue(await value())
   }
   // Nested Json
-  if (type === 'object' && value.functions && value.functions.toJson) {
-    return _getValue(await value.functions.toJson())
+  if (type === 'object' && value.functions && value.functions.toObj) {
+    return _getValue(await value.functions.toObj())
   }
   // Dates
   if (type === 'object' && value.toISOString) {
@@ -30,7 +30,7 @@ const _shouldIgnoreKey = key => {
   return IGNORABLE_KEYS.includes(key)
 }
 
-const toJson = keyToFunc => async () => {
+const toObj = keyToFunc => async () => {
   return Object.entries(keyToFunc).reduce(async (acc, [key, value]) => {
     const realAcc = await acc
     if (_shouldIgnoreKey(key)) {
@@ -43,5 +43,5 @@ const toJson = keyToFunc => async () => {
 }
 
 module.exports = {
-  toJson,
+  toObj,
 }

package/src/utils.js

@@ -6,7 +6,7 @@ const toTitleCase = string => {
   return `${string.slice(0, 1).toUpperCase()}${string.slice(1)}`
 }
 
-const createPropertyTitle = key => {
+const createFieldTitle = key => {
   const goodName = toTitleCase(key)
   return `get${goodName}`
 }
@@ -37,6 +37,6 @@ const loweredTitleCase = string => {
 module.exports = {
   createUuid,
   loweredTitleCase,
-  createPropertyTitle,
+  createPropertyTitle: createFieldTitle,
   toTitleCase,
 }

package/src/validation.js

@@ -28,13 +28,7 @@ const isType = type => value => {
   return _typeOrError(type, `Must be a ${type}`)(value)
 }
 const isNumber = isType('number')
-const isInteger = _trueOrError(v => {
-  const numberError = isNumber(v)
-  if (numberError) {
-    return false
-  }
-  return Number.isNaN(parseInt(v, 10)) === false
-}, 'Must be an integer')
+const isInteger = _trueOrError(Number.isInteger, 'Must be an integer')
 
 const isBoolean = isType('boolean')
 const isString = isType('string')
@@ -69,8 +63,15 @@ const meetsRegex =
   }
 
 const choices = choiceArray => value => {
-  if (choiceArray.includes(value) === false) {
-    return 'Not a valid choice'
+  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
 }
@@ -129,16 +130,20 @@ const minTextLength = min => value => {
   return undefined
 }
 
-const aggregateValidator = methodOrMethods => async value => {
+const aggregateValidator = methodOrMethods => {
   const toDo = Array.isArray(methodOrMethods)
     ? methodOrMethods
     : [methodOrMethods]
-  const values = await Promise.all(
-    toDo.map(method => {
-      return method(value)
-    })
-  )
-  return values.filter(x => x)
+
+  const _aggregativeValidator = async value => {
+    const values = await Promise.all(
+      toDo.map(method => {
+        return method(value)
+      })
+    )
+    return values.filter(x => x)
+  }
+  return _aggregativeValidator
 }
 
 const emptyValidator = () => []
@@ -153,6 +158,7 @@ const CONFIG_TO_VALIDATE_METHOD = {
   isNumber: _boolChoice(isNumber),
   isString: _boolChoice(isString),
   isArray: _boolChoice(isArray),
+  choices,
 }
 
 const createFieldValidator = config => {
@@ -164,24 +170,33 @@ const createFieldValidator = config => {
   ].filter(x => x)
   const validator =
     validators.length > 0 ? aggregateValidator(validators) : emptyValidator
-  return async value => {
+  const _fieldValidator = async value => {
     const errors = await validator(value)
     return [...new Set(flatMap(errors))]
   }
-}
-
-const createModelValidator = fields => async () => {
-  const keysAndFunctions = Object.entries(get(fields, 'functions.validate', {}))
-  const data = await Promise.all(
-    keysAndFunctions.map(async ([key, validator]) => {
-      return [key, await validator()]
-    })
-  )
-  return data
-    .filter(([_, errors]) => Boolean(errors) && errors.length > 0)
-    .reduce((acc, [key, errors]) => {
-      return { ...acc, [key]: errors }
-    }, {})
+  return _fieldValidator
+}
+
+const createModelValidator = fields => {
+  const _modelValidator = async () => {
+    const keysAndFunctions = Object.entries(
+      get(fields, 'functions.validate', {})
+    )
+    const data = await Promise.all(
+      keysAndFunctions.map(async ([key, validator]) => {
+        if (key === 'model') {
+          return [key, []]
+        }
+        return [key, await validator()]
+      })
+    )
+    return data
+      .filter(([_, errors]) => Boolean(errors) && errors.length > 0)
+      .reduce((acc, [key, errors]) => {
+        return { ...acc, [key]: errors }
+      }, {})
+  }
+  return _modelValidator
 }
 
 module.exports = {

package/test/src/fields.test.js

@@ -5,10 +5,297 @@ const {
   dateField,
   referenceField,
   arrayField,
+  constantValueField,
+  objectField,
+  numberField,
+  textField,
+  integerField,
+  emailField,
 } = require('../../src/fields')
+const { TYPE_PRIMATIVES, arrayType } = require('../../src/validation')
 const { createModel } = require('../../src/models')
 
 describe('/src/fields.js', () => {
+  describe('#emailField()', () => {
+    describe('#createGetter()', () => {
+      it('should be able to create without a config', () => {
+        assert.doesNotThrow(() => {
+          emailField()
+        })
+      })
+      it('should always have the value passed in', async () => {
+        const fieldInstance = emailField({})
+        const getter = fieldInstance.createGetter('testme@email.com')
+        const actual = await getter()
+        const expected = 'testme@email.com'
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const fieldInstance = emailField({})
+        const getter = fieldInstance.createGetter('testme@email.com')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+  describe('#constantValueField()', () => {
+    describe('#createGetter()', () => {
+      it('should always have the value passed in', async () => {
+        const fieldInstance = constantValueField('constant')
+        const getter = fieldInstance.createGetter('changed')
+        const actual = await getter()
+        const expected = 'constant'
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const fieldInstance = constantValueField('constant')
+        const getter = fieldInstance.createGetter('changed')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+  describe('#objectField()', () => {
+    describe('#createGetter()', () => {
+      it('should be able to create without a config', () => {
+        assert.doesNotThrow(() => {
+          objectField()
+        })
+      })
+      it('should be able to get the object passed in', async () => {
+        const fieldInstance = objectField({})
+        const getter = fieldInstance.createGetter({
+          my: 'object',
+          complex: { it: 'is' },
+        })
+        const actual = await getter()
+        const expected = { my: 'object', complex: { it: 'is' } }
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const fieldInstance = objectField({})
+        const getter = fieldInstance.createGetter({
+          my: 'object',
+          complex: { it: 'is' },
+        })
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+
+  describe('#numberField()', () => {
+    describe('#createGetter()', () => {
+      it('should be able to create without a config', () => {
+        assert.doesNotThrow(() => {
+          numberField()
+        })
+      })
+      it('should be able to get the number passed in', async () => {
+        const fieldInstance = numberField({})
+        const getter = fieldInstance.createGetter(5)
+        const actual = await getter()
+        const expected = 5
+        assert.equal(actual, expected)
+      })
+      it('should be able to get float passed in', async () => {
+        const fieldInstance = numberField({})
+        const getter = fieldInstance.createGetter(5.123)
+        const actual = await getter()
+        const expected = 5.123
+        assert.equal(actual, expected)
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const fieldInstance = numberField({})
+        const getter = fieldInstance.createGetter(5)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+      it('should return and validate successful with a basic float', async () => {
+        const fieldInstance = numberField({})
+        const getter = fieldInstance.createGetter(5.123)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a non integer input', async () => {
+        const fieldInstance = numberField({})
+        const getter = fieldInstance.createGetter('string')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value=5 and maxValue=3', async () => {
+        const fieldInstance = numberField({ maxValue: 3 })
+        const getter = fieldInstance.createGetter(5)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value=2 and minValue=3', async () => {
+        const fieldInstance = numberField({ minValue: 3 })
+        const getter = fieldInstance.createGetter(2)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with no errors with a value=3 and minValue=3 and maxValue=3', async () => {
+        const fieldInstance = numberField({ minValue: 3, maxValue: 3 })
+        const getter = fieldInstance.createGetter(3)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+
+  describe('#integerField()', () => {
+    describe('#createGetter()', () => {
+      it('should be able to create without a config', () => {
+        assert.doesNotThrow(() => {
+          integerField()
+        })
+      })
+      it('should be able to get the number passed in', async () => {
+        const fieldInstance = integerField({})
+        const getter = fieldInstance.createGetter(5)
+        const actual = await getter()
+        const expected = 5
+        assert.equal(actual, expected)
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const fieldInstance = integerField({})
+        const getter = fieldInstance.createGetter(5)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+      it('should return errors with a basic float', async () => {
+        const fieldInstance = integerField({})
+        const getter = fieldInstance.createGetter(5.123)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a non integer input', async () => {
+        const fieldInstance = integerField({})
+        const getter = fieldInstance.createGetter('string')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value=5 and maxValue=3', async () => {
+        const fieldInstance = integerField({ maxValue: 3 })
+        const getter = fieldInstance.createGetter(5)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value=2 and minValue=3', async () => {
+        const fieldInstance = integerField({ minValue: 3 })
+        const getter = fieldInstance.createGetter(2)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with no errors with a value=3 and minValue=3 and maxValue=3', async () => {
+        const fieldInstance = integerField({ minValue: 3, maxValue: 3 })
+        const getter = fieldInstance.createGetter(3)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+
+  describe('#textField()', () => {
+    describe('#createGetter()', () => {
+      it('should be able to create without a config', () => {
+        assert.doesNotThrow(() => {
+          textField()
+        })
+      })
+      it('should be able to get the value passed in', async () => {
+        const fieldInstance = textField({})
+        const getter = fieldInstance.createGetter('basic input')
+        const actual = await getter()
+        const expected = 'basic input'
+        assert.equal(actual, expected)
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const fieldInstance = textField({})
+        const getter = fieldInstance.createGetter('basic input')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value=5', async () => {
+        const fieldInstance = textField({})
+        const getter = fieldInstance.createGetter(5)
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value="hello" and maxLength=3', async () => {
+        const fieldInstance = textField({ maxLength: 3 })
+        const getter = fieldInstance.createGetter('hello')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with errors with a value="hello" and minLength=10', async () => {
+        const fieldInstance = textField({ minLength: 10 })
+        const getter = fieldInstance.createGetter('hello')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
+      it('should return with no errors with a value="hello" and minLength=5 and maxLength=5', async () => {
+        const fieldInstance = textField({ minLength: 5, maxLength: 5 })
+        const getter = fieldInstance.createGetter('hello')
+        const validator = fieldInstance.getValidator(getter)
+        const actual = await validator()
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+
   describe('#arrayField()', () => {
     describe('#createGetter()', () => {
       it('should return an array passed in without issue', async () => {
@@ -49,6 +336,32 @@ describe('/src/fields.js', () => {
         const expected = []
         assert.deepEqual(actual, expected)
       })
+      it('should error an array passed in when it doesnt have the right types', async () => {
+        const theField = arrayField({
+          validators: [arrayType(TYPE_PRIMATIVES.integer)],
+        })
+        const getter = theField.createGetter([1, 'string', 3])
+        const validator = theField.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.deepEqual(actual.length, expected)
+      })
+      it('should validate an array with [4,4,5,5,6,6] when choices are [4,5,6]', async () => {
+        const theField = arrayField({ choices: [4, 5, 6] })
+        const getter = theField.createGetter([4, 4, 5, 5, 6, 6])
+        const validator = theField.getValidator(getter)
+        const actual = await validator()
+        const expected = []
+        assert.deepEqual(actual, expected)
+      })
+      it('should return errors when an array with [4,4,3,5,5,6,6] when choices are [4,5,6]', async () => {
+        const theField = arrayField({ choices: [4, 5, 6] })
+        const getter = theField.createGetter([4, 4, 3, 5, 5, 6, 6])
+        const validator = theField.getValidator(getter)
+        const actual = await validator()
+        const expected = 1
+        assert.equal(actual.length, expected)
+      })
     })
   })
   describe('#field()', () => {
@@ -168,7 +481,7 @@ describe('/src/fields.js', () => {
         assert.deepEqual(actual, expected)
       })
       it('should take the smartObject as a value', async () => {
-        const proto = createModel({
+        const proto = createModel('name', {
           id: uniqueId({ value: 'obj-id' }),
         })
         const input = [proto({ id: 'obj-id' })]
@@ -177,23 +490,23 @@ describe('/src/fields.js', () => {
         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({
+      describe('#functions.toObj()', () => {
+        it('should use the getId of the smartObject passed in when toObj is called', async () => {
+          const proto = createModel('name', {
             id: uniqueId({ value: 'obj-id' }),
           })
           const input = [proto({ id: 'obj-id' })]
           const instance = await referenceField({}).createGetter(...input)()
-          const actual = await instance.functions.toJson()
+          const actual = await instance.functions.toObj()
           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 () => {
+        it('should return "obj-id" when switch-a-roo fetcher is used and toObj 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 actual = await instance.functions.toObj()
           const expected = 'obj-id'
           assert.deepEqual(actual, expected)
         })

package/test/src/models.test.js

@@ -1,3 +1,4 @@
+const _ = require('lodash')
 const assert = require('chai').assert
 const { createModel } = require('../../src/models')
 const { field } = require('../../src/fields')
@@ -5,16 +6,53 @@ 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 actual = createModel('name', {})
       const expected = 'function'
       assert.isFunction(actual)
     })
     describe('#()', () => {
+      it('should not throw an exception if nothing is passed into function', () => {
+        const input = {
+          myField: field({ required: true }),
+        }
+        const model = createModel('name', input)
+        assert.doesNotThrow(() => {
+          model()
+        })
+      })
+      it('should return an object that contains meta.fields.myField', () => {
+        const input = {
+          myField: field({ required: true }),
+        }
+        const model = createModel('name', input)
+        const instance = model({ myField: 'value' })
+        const actual = _.get(instance, 'meta.fields.myField')
+        assert.isOk(actual)
+      })
+      it('should return an object that contains meta.modelName===test-the-name', () => {
+        const input = {
+          myField: field({ required: true }),
+        }
+        const model = createModel('test-the-name', input)
+        const instance = model({ myField: 'value' })
+        const actual = _.get(instance, 'meta.modelName')
+        const expected = 'test-the-name'
+        assert.deepEqual(actual, expected)
+      })
+      it('should return an object that contains meta.fields.myField', () => {
+        const input = {
+          myField: field({ required: true }),
+        }
+        const model = createModel('name', input)
+        const instance = model({ myField: 'value' })
+        const actual = _.get(instance, 'meta.fields.myField')
+        assert.isOk(actual)
+      })
       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 model = createModel('name', input)
         const instance = model({ myField: 'passed-in' })
         const actual = await instance.getMyField()
         const expected = 'passed-in'
@@ -24,7 +62,7 @@ describe('/src/models.js', () => {
         const input = {
           myField: field({ value: 'value', defaultValue: 'default-value' }),
         }
-        const model = createModel(input)
+        const model = createModel('name', input)
         const instance = model({ myField: 'passed-in' })
         const actual = await instance.getMyField()
         const expected = 'value'
@@ -34,7 +72,7 @@ describe('/src/models.js', () => {
         const input = {
           myField: field({ value: 'value' }),
         }
-        const model = createModel(input)
+        const model = createModel('name', input)
         const instance = model({ myField: 'passed-in' })
         const actual = await instance.getMyField()
         const expected = 'value'
@@ -44,7 +82,7 @@ describe('/src/models.js', () => {
         const input = {
           myField: field({ defaultValue: 'defaultValue' }),
         }
-        const model = createModel(input)
+        const model = createModel('name', input)
         const instance = model({})
         const actual = await instance.getMyField()
         const expected = 'defaultValue'
@@ -54,7 +92,7 @@ describe('/src/models.js', () => {
         const input = {
           myField: field({ defaultValue: 'defaultValue' }),
         }
-        const model = createModel(input)
+        const model = createModel('name', input)
         const instance = model({ myField: null })
         const actual = await instance.getMyField()
         const expected = 'defaultValue'
@@ -65,9 +103,8 @@ describe('/src/models.js', () => {
           id: field({ required: true }),
           type: field(),
         }
-        const model = createModel(input)
+        const model = createModel('name', input)
         const actual = model({ id: 'my-id', type: 'my-type' })
-        console.log(actual)
         assert.isOk(actual.getId)
         assert.isOk(actual.getType)
       })
@@ -76,21 +113,20 @@ describe('/src/models.js', () => {
           id: field({ required: true }),
           type: field(),
         }
-        const model = createModel(input)
+        const model = createModel('name', 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({})
+      const actual = createModel('name', {})
       assert.isFunction(actual)
     })
     it('should throw an exception if a key "model" is passed in', () => {
       assert.throws(() => {
-        createModel({ model: 'weeee' })
+        createModel('name', { model: 'weeee' })
       })
     })
   })

package/test/src/serialization.test.js

@@ -1,10 +1,10 @@
 const assert = require('chai').assert
-const { toJson } = require('../../src/serialization')
+const { toObj } = require('../../src/serialization')
 
 describe('/src/serialization.js', () => {
-  describe('#toJson()', () => {
+  describe('#toObj()', () => {
     it('serialize a very basic input of key-value', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         key: 'value',
         key2: 'value2',
       })()
@@ -15,7 +15,7 @@ describe('/src/serialization.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should ignore "meta" properties', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         key: 'value',
         key2: 'value2',
         meta: {
@@ -29,7 +29,7 @@ describe('/src/serialization.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should ignore "functions" properties', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         key: 'value',
         key2: 'value2',
         functions: {
@@ -44,13 +44,13 @@ describe('/src/serialization.js', () => {
       }
       assert.deepEqual(actual, expected)
     })
-    it('should call "functions.toJson" on nested objects', async () => {
-      const actual = await toJson({
+    it('should call "functions.toObj" on nested objects', async () => {
+      const actual = await toObj({
         key: 'value',
         key2: {
           complex: () => ({ func: 'func' }),
           functions: {
-            toJson: () => ({ func: 'value' }),
+            toObj: () => ({ func: 'value' }),
           },
         },
       })()
@@ -62,12 +62,12 @@ describe('/src/serialization.js', () => {
       }
       assert.deepEqual(actual, expected)
     })
-    it('should call "toJson" on very nested objects', async () => {
-      const actual = await toJson({
+    it('should call "toObj" on very nested objects', async () => {
+      const actual = await toObj({
         key: 'value',
         key2: {
           functions: {
-            toJson: () => ({ func: 'value' }),
+            toObj: () => ({ func: 'value' }),
           },
         },
       })()
@@ -80,7 +80,7 @@ describe('/src/serialization.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should set an undefined property to null', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         key: 'value',
         key2: undefined,
       })()
@@ -91,7 +91,7 @@ describe('/src/serialization.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should get the value of a function', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         key: 'value',
         key2: () => {
           return 'funcvalue'
@@ -104,7 +104,7 @@ describe('/src/serialization.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should change property getTheValue to "theValue"', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         key: 'value',
         getTheValue: () => 'funcvalue',
       })()
@@ -115,7 +115,7 @@ describe('/src/serialization.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should return "2021-09-16T21:51:56.039Z" for the set date.', async () => {
-      const actual = await toJson({
+      const actual = await toObj({
         myDate: new Date('2021-09-16T21:51:56.039Z'),
       })()
       const expected = {

package/test/src/validation.test.js

@@ -258,6 +258,20 @@ describe('/src/validation.js', () => {
       sinon.assert.calledOnce(fields.functions.validate.id)
       sinon.assert.calledOnce(fields.functions.validate.type)
     })
+    it('should not run a validate.model function', async () => {
+      const fields = {
+        functions: {
+          validate: {
+            id: sinon.stub().returns(undefined),
+            type: sinon.stub().returns(undefined),
+            model: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(fields)
+      await validator()
+      sinon.assert.notCalled(fields.functions.validate.model)
+    })
     it('should combine results for both functions.validate for two objects that error', async () => {
       const fields = {
         functions: {