functional-models 1.0.9 → 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/stepDefinitions/steps.js

@@ -4,24 +4,24 @@ 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: createModel("ArrayModel4", {
     arrayField: arrayField({
       choices: [4, 5, 6],
       validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functional-models",
-  "version": "1.0.9",
+  "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

@@ -53,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
     },
   }
 }
@@ -101,7 +103,7 @@ const referenceField = config => {
           ...objToUse,
           functions: {
             ...(objToUse.functions ? objToUse.functions : {}),
-            toJson: _getId,
+            toObj: _getId,
           },
         }
       }

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

@@ -130,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 = () => []
@@ -166,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

@@ -481,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' })]
@@ -490,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,7 +6,7 @@ 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)
     })
@@ -14,16 +15,44 @@ describe('/src/models.js', () => {
         const input = {
           myField: field({ required: true }),
         }
-        const model = createModel(input)
+        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'
@@ -33,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'
@@ -43,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'
@@ -53,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'
@@ -63,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'
@@ -74,7 +103,7 @@ 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' })
         assert.isOk(actual.getId)
         assert.isOk(actual.getType)
@@ -84,7 +113,7 @@ 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
@@ -92,12 +121,12 @@ describe('/src/models.js', () => {
       })
     })
     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: {