functional-models 1.0.18 → 1.0.23

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "functional-models",
-  "version": "1.0.18",
+  "version": "1.0.23",
   "description": "A library for creating JavaScript function based models.",
   "main": "index.js",
   "scripts": {
-    "test": "nyc --all mocha --recursive ./test/**/*.test.js",
+    "test": "nyc --all mocha --recursive './test/**/*.test.js'",
     "feature-tests": "./node_modules/@cucumber/cucumber/bin/cucumber-js",
     "coverage": "nyc --all --reporter=lcov npm test"
   },
@@ -49,7 +49,6 @@
   },
   "dependencies": {
     "get-random-values": "^1.2.2",
-    "lazy-property": "^1.0.0",
     "lodash": "^4.17.21"
   }
 }

package/src/models.js

@@ -2,14 +2,16 @@ const merge = require('lodash/merge')
 const { toObj } = require('./serialization')
 const { createPropertyTitle } = require('./utils')
 const { createModelValidator } = require('./validation')
+const { UniqueId } = require('./properties')
 
 const MODEL_DEF_KEYS = ['meta', 'functions']
-const PROTECTED_KEYS = ['model']
 
 const Model = (
   modelName,
   keyToProperty,
   {
+    primaryKey = 'id',
+    getPrimaryKeyProperty=() => UniqueId({required: true}),
     instanceCreatedCallback = null,
     modelFunctions = {},
     instanceFunctions = {},
@@ -25,11 +27,11 @@ const Model = (
    */
   // eslint-disable-next-line functional/no-let
   let model = null
-  PROTECTED_KEYS.forEach(key => {
-    if (key in keyToProperty) {
-      throw new Error(`Cannot use ${key}. This is a protected value.`)
-    }
-  })
+  keyToProperty = {
+    // this key exists over keyToProperty, so it can be overrided if desired.
+    [primaryKey]: getPrimaryKeyProperty(),
+    ...keyToProperty,
+  }
   const instanceProperties = Object.entries(keyToProperty).filter(
     ([key, _]) => MODEL_DEF_KEYS.includes(key) === false
   )
@@ -78,6 +80,7 @@ const Model = (
       },
       functions: {
         toObj: toObj(loadedInternals),
+        getPrimaryKey: loadedInternals[createPropertyTitle(primaryKey)],
         validate: {
           model: () =>
             createModelValidator(loadedInternals, modelValidators)(instance),
@@ -125,6 +128,7 @@ const Model = (
     create,
     getName: () => modelName,
     getProperties: () => properties,
+    getPrimaryKeyName: () => primaryKey,
   })
   return model
 }

package/src/properties.js

@@ -1,4 +1,5 @@
 const identity = require('lodash/identity')
+const get = require('lodash/get')
 const isFunction = require('lodash/isFunction')
 const merge = require('lodash/merge')
 const {
@@ -57,8 +58,8 @@ const Property = (config = {}, additionalMetadata = {}) => {
     },
     getValidator: valueGetter => {
       const validator = createPropertyValidator(config)
-      const _propertyValidatorWrapper = async () => {
-        return validator(await valueGetter())
+      const _propertyValidatorWrapper = async (instance, instanceData) => {
+        return validator(await valueGetter(), instance, instanceData)
       }
       return _propertyValidatorWrapper
     },
@@ -106,17 +107,26 @@ const ReferenceProperty = (model, config = {}) => {
       if (!instanceValues) {
         return null
       }
-      return instanceValues && instanceValues.id
-        ? instanceValues.id
-        : instanceValues.getId
-        ? instanceValues.getId()
-        : instanceValues
+      const theModel = _getModel()
+      const primaryKey = theModel.getPrimaryKeyName()
+      if (instanceValues[primaryKey]) {
+        return instanceValues[primaryKey]
+      }
+      const primaryKeyFunc = get(instanceValues, 'functions.getPrimaryKey')
+      if (primaryKeyFunc) {
+        return primaryKeyFunc()
+      }
+      return instanceValues
     }
+
     const valueIsModelInstance =
       Boolean(instanceValues) && Boolean(instanceValues.functions)
 
     const _getInstanceReturn = objToUse => {
-      const instance = valueIsModelInstance
+      // We need to determine if the object we just go is an actual model instance to determine if we need to make one.
+      const objIsModelInstance =
+        Boolean(objToUse) && Boolean(objToUse.functions)
+      const instance = objIsModelInstance
         ? objToUse
         : _getModel().create(objToUse)
       return merge({}, instance, {
@@ -131,7 +141,8 @@ const ReferenceProperty = (model, config = {}) => {
     }
     if (config.fetcher) {
       const id = await _getId()
-      const obj = await config.fetcher(_getModel(), id)
+      const model = _getModel()
+      const obj = await config.fetcher(model, id)
       return _getInstanceReturn(obj)
     }
     return _getId(instanceValues)

package/src/validation.js

@@ -208,11 +208,11 @@ const createPropertyValidator = config => {
     : validators.includes(isRequired)
   const validator =
     validators.length > 0 ? aggregateValidator(validators) : emptyValidator
-  const _propertyValidator = async value => {
+  const _propertyValidator = async (value, instance, instanceData) => {
     if (!value && !isRequiredValue) {
       return []
     }
-    const errors = await validator(value)
+    const errors = await validator(value, instance, instanceData)
     return [...new Set(flatMap(errors))]
   }
   return _propertyValidator
@@ -223,20 +223,22 @@ const createModelValidator = (properties, modelValidators = []) => {
     const keysAndFunctions = Object.entries(
       get(properties, 'functions.validate', {})
     )
+    const instanceData = await (modelValidators.length > 0
+      ? instance.functions.toObj()
+      : {})
     const data = await Promise.all(
       keysAndFunctions.map(async ([key, validator]) => {
         if (key === 'model') {
           return [key, []]
         }
-        return [key, await validator()]
+        return [key, await validator(instance, instanceData)]
       })
     )
-    const instanceData = await (modelValidators.length > 0
-      ? instance.functions.toObj()
-      : {})
-    const modelValidationErrors = (await Promise.all(
-      modelValidators.map(validator => validator(instance, instanceData))
-    )).filter(x=>x)
+    const modelValidationErrors = (
+      await Promise.all(
+        modelValidators.map(validator => validator(instance, instanceData))
+      )
+    ).filter(x => x)
     const propertyErrors = data
       .filter(([_, errors]) => Boolean(errors) && errors.length > 0)
       .reduce((acc, [key, errors]) => {

package/test/src/models.test.js

@@ -60,7 +60,57 @@ describe('/src/models.js', () => {
       )
       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 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',
@@ -234,5 +284,42 @@ describe('/src/models.js', () => {
         Model('name', { model: 'weeee' }).create()
       })
     })
+    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)
+      })
+    })
   })
 })

package/test/src/validation.test.js

@@ -408,7 +408,10 @@ describe('/src/validation.js', () => {
           },
         },
       }
-      const validator = createModelValidator(properties, [modelValidator1, modelValidator2])
+      const validator = createModelValidator(properties, [
+        modelValidator1,
+        modelValidator2,
+      ])
       const instance = testModel3.create({
         id: 'test-id',
         name: 'my-name',