functional-models 1.0.24 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functional-models",
-  "version": "1.0.24",
+  "version": "1.0.28",
   "description": "A library for creating JavaScript function based models.",
   "main": "index.js",
   "scripts": {
@@ -49,6 +49,7 @@
     "sinon": "^11.1.2"
   },
   "dependencies": {
+    "async-lock": "^1.3.0",
     "get-random-values": "^1.2.2",
     "lodash": "^4.17.21"
   }

package/src/constants.js

@@ -0,0 +1,19 @@
+const { getObjToArray } = require('./utils')
+
+const PROPERTY_TYPES = getObjToArray([
+  'UniqueId',
+  'DateProperty',
+  'ArrayProperty',
+  'ReferenceProperty',
+  'IntegerProperty',
+  'TextProperty',
+  'ConstantValueProperty',
+  'NumberProperty',
+  'ObjectProperty',
+  'EmailProperty',
+  'BooleanProperty',
+])
+
+module.exports = {
+  PROPERTY_TYPES,
+}

package/src/errors.js

@@ -0,0 +1,16 @@
+/* eslint-disable functional/no-this-expression */
+/* eslint-disable functional/no-class */
+class ValidationError extends Error {
+  constructor(modelName, keysToErrors) {
+    super(`${modelName} did not pass validation`)
+    this.name = 'ValidationError'
+    this.modelName = modelName
+    this.keysToErrors = keysToErrors
+  }
+}
+/* eslint-enable functional/no-this-expression */
+/* eslint-enable functional/no-class */
+
+module.exports = {
+  ValidationError,
+}

package/src/index.js

@@ -1,7 +1,10 @@
 module.exports = {
+  constants: require('./constants'),
   ...require('./properties'),
   ...require('./models'),
   ...require('./functions'),
+  errors: require('./errors'),
   validation: require('./validation'),
   serialization: require('./serialization'),
+  utils: require('./utils'),
 }

package/src/lazy.js

@@ -1,15 +1,22 @@
+const AsyncLock = require('async-lock')
+const { createUuid } = require('./utils')
+
 const lazyValue = method => {
+  const key = createUuid()
+  const lock = new AsyncLock()
   /* eslint-disable functional/no-let */
   let value = undefined
   let called = false
   return async (...args) => {
-    if (!called) {
-      value = await method(...args)
-      // eslint-disable-next-line require-atomic-updates
-      called = true
-    }
-
-    return value
+    return lock.acquire(key, async () => {
+      if (!called) {
+        called = true
+        value = await method(...args)
+        // eslint-disable-next-line require-atomic-updates
+      }
+    }).then(() => {
+      return value
+    })
   }
   /* eslint-enable functional/no-let */
 }

package/src/models.js

@@ -1,8 +1,8 @@
 const merge = require('lodash/merge')
+const get = require('lodash/get')
 const { toObj } = require('./serialization')
-const { createPropertyTitle } = require('./utils')
 const { createModelValidator } = require('./validation')
-const { UniqueId } = require('./properties')
+const { UniqueId, createPropertyTitle } = require('./properties')
 
 const MODEL_DEF_KEYS = ['meta', 'functions']
 
@@ -65,12 +65,24 @@ const Model = (
         const fleshedOutInstanceProperties = {
           [getPropertyKey]: propertyGetter,
           functions: {
+            getters: {
+              [key]:  propertyGetter,
+            },
             validators: {
               [key]: propertyValidator,
             },
           },
         }
-        return merge(acc, fleshedOutInstanceProperties)
+        const referenceProperties = get(property, 'meta.getReferencedId')
+          ? {
+            meta: {
+              references: {
+                [createPropertyTitle(`${key}Id`)]: () => property.meta.getReferencedId(instanceValues[key])
+              }
+            }
+          }
+          : {}
+        return merge(acc, fleshedOutInstanceProperties, referenceProperties)
       },
       {}
     )
@@ -81,11 +93,11 @@ const Model = (
       functions: {
         toObj: toObj(loadedInternals),
         getPrimaryKey: loadedInternals[createPropertyTitle(primaryKey)],
-        validate: () => {
+        validate: (options={}) => {
           return createModelValidator(
             loadedInternals,
             modelValidators
-          )(instance)
+          )(instance, options)
         },
       },
     }
@@ -95,7 +107,7 @@ const Model = (
       return merge(acc, {
         functions: {
           [key]: (...args) => {
-            return func(instance)(...args)
+            return func(...args, instance)
           },
         },
       })

package/src/properties.js

@@ -13,8 +13,14 @@ const {
   referenceTypeMatch,
   meetsRegex,
 } = require('./validation')
-const { createUuid } = require('./utils')
+const { PROPERTY_TYPES } = require('./constants')
 const { lazyValue } = require('./lazy')
+const { toTitleCase, createUuid } = require('./utils')
+
+const createPropertyTitle = key => {
+  const goodName = toTitleCase(key)
+  return `get${goodName}`
+}
 
 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
@@ -30,21 +36,36 @@ const _mergeValidators = (config, validators) => {
   return [...validators, ...(config.validators ? config.validators : [])]
 }
 
-const Property = (config = {}, additionalMetadata = {}) => {
-  const value = config.value || undefined
-  const defaultValue = config.defaultValue || undefined
+const Property = (type, config = {}, additionalMetadata = {}) => {
+  if (!type && !config.type) {
+    throw new Error(`Property type must be provided.`)
+  }
+  if (config.type) {
+    type = config.type
+  }
+  const getConstantValue = () => config.value !== undefined ? config.value : undefined
+  const getDefaultValue = () => config.defaultValue !== undefined ? config.defaultValue : undefined
+  const getChoices = () => config.choices ? config.choices : []
   const lazyLoadMethod = config.lazyLoadMethod || false
   const valueSelector = config.valueSelector || identity
   if (typeof valueSelector !== 'function') {
     throw new Error(`valueSelector must be a function`)
   }
 
+
   return {
     ...additionalMetadata,
+    getConfig: () => config,
+    getChoices,
+    getDefaultValue,
+    getConstantValue,
+    getPropertyType: () => type,
     createGetter: instanceValue => {
+      const value = getConstantValue()
       if (value !== undefined) {
         return () => value
       }
+      const defaultValue = getDefaultValue()
       if (
         defaultValue !== undefined &&
         (instanceValue === null || instanceValue === undefined)
@@ -62,37 +83,25 @@ const Property = (config = {}, additionalMetadata = {}) => {
     },
     getValidator: valueGetter => {
       const validator = createPropertyValidator(config)
-      const _propertyValidatorWrapper = async (instance, instanceData) => {
-        return validator(await valueGetter(), instance, instanceData)
+      const _propertyValidatorWrapper = async (instance, instanceData, options={}) => {
+        return validator(await valueGetter(), instance, instanceData, options)
       }
       return _propertyValidatorWrapper
     },
   }
 }
 
-const UniqueId = (config = {}) =>
-  Property({
-    ...config,
-    lazyLoadMethod: value => {
-      if (!value) {
-        return createUuid()
-      }
-      return value
-    },
-  })
-
-const DateProperty = (config = {}) =>
-  Property({
-    ...config,
-    lazyLoadMethod: value => {
-      if (!value && config.autoNow) {
-        return new Date()
-      }
-      return value
-    },
-  })
+const DateProperty = (config = {}, additionalMetadata={}) => Property(PROPERTY_TYPES.DateProperty, {
+  ...config,
+  lazyLoadMethod: value => {
+    if (!value && config.autoNow) {
+      return new Date()
+    }
+    return value
+  },
+}, additionalMetadata)
 
-const ReferenceProperty = (model, config = {}) => {
+const ReferenceProperty = (model, config = {}, additionalMetadata={}) => {
   if (!model) {
     throw new Error('Must include the referenced model')
   }
@@ -106,22 +115,23 @@ const ReferenceProperty = (model, config = {}) => {
 
   const validators = _mergeValidators(config, [referenceTypeMatch(model)])
 
-  const lazyLoadMethod = async instanceValues => {
-    const _getId = () => {
-      if (!instanceValues) {
-        return null
-      }
-      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 _getId = (instanceValues) => () => {
+    if (!instanceValues) {
+      return null
+    }
+    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 lazyLoadMethod = async instanceValues => {
 
     const valueIsModelInstance =
       Boolean(instanceValues) && Boolean(instanceValues.functions)
@@ -135,7 +145,7 @@ const ReferenceProperty = (model, config = {}) => {
         : _getModel().create(objToUse)
       return merge({}, instance, {
         functions: {
-          toObj: _getId,
+          toObj: _getId(instanceValues),
         },
       })
     }
@@ -144,43 +154,51 @@ const ReferenceProperty = (model, config = {}) => {
       return _getInstanceReturn(instanceValues)
     }
     if (config.fetcher) {
-      const id = await _getId()
+      const id = await _getId(instanceValues)()
       const model = _getModel()
       const obj = await config.fetcher(model, id)
       return _getInstanceReturn(obj)
     }
-    return _getId(instanceValues)
+    return _getId(instanceValues)()
   }
 
   return Property(
+    PROPERTY_TYPES.ReferenceProperty,
     merge({}, config, {
       validators,
       lazyLoadMethod,
     }),
     {
+      ...additionalMetadata,
       meta: {
+        getReferencedId: (instanceValues) => _getId(instanceValues)(),
         getReferencedModel: _getModel,
       },
     }
   )
 }
 
-const ArrayProperty = (config = {}) =>
-  Property({
+const ArrayProperty = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.ArrayProperty,
+    {
     defaultValue: [],
     ...config,
     isArray: true,
-  })
+  }, additionalMetadata)
 
-const ObjectProperty = (config = {}) =>
+const ObjectProperty = (config = {}, additionalMetadata={}) =>
   Property(
+    PROPERTY_TYPES.ObjectProperty,
     merge(config, {
       validators: _mergeValidators(config, [isType('object')]),
-    })
+    }),
+    additionalMetadata
   )
 
-const TextProperty = (config = {}) =>
+const TextProperty = (config = {}, additionalMetadata={} ) =>
   Property(
+    PROPERTY_TYPES.TextProperty,
     merge(config, {
       isString: true,
       validators: _mergeValidators(config, [
@@ -191,11 +209,13 @@ const TextProperty = (config = {}) =>
           minTextLength(value)
         ),
       ]),
-    })
+    }),
+    additionalMetadata
   )
 
-const IntegerProperty = (config = {}) =>
+const IntegerProperty = (config = {}, additionalMetadata={}) =>
   Property(
+    PROPERTY_TYPES.IntegerProperty,
     merge(config, {
       isInteger: true,
       validators: _mergeValidators(config, [
@@ -206,11 +226,13 @@ const IntegerProperty = (config = {}) =>
           maxNumber(value)
         ),
       ]),
-    })
+    }),
+    additionalMetadata
   )
 
-const NumberProperty = (config = {}) =>
+const NumberProperty = (config = {}, additionalMetadata={}) =>
   Property(
+    PROPERTY_TYPES.NumberProperty,
     merge(config, {
       isNumber: true,
       validators: _mergeValidators(config, [
@@ -221,23 +243,59 @@ const NumberProperty = (config = {}) =>
           maxNumber(value)
         ),
       ]),
-    })
+    }),
+    additionalMetadata
   )
 
-const ConstantValueProperty = (value, config = {}) =>
+const ConstantValueProperty = (value, config = {}, additionalMetadata={}) =>
   TextProperty(
     merge(config, {
+      type: PROPERTY_TYPES.ConstantValueProperty,
       value,
-    })
+    }),
+    additionalMetadata
   )
 
-const EmailProperty = (config = {}) =>
+const EmailProperty = (config = {}, additionalMetadata={}) =>
   TextProperty(
     merge(config, {
+      type: PROPERTY_TYPES.EmailProperty,
       validators: _mergeValidators(config, [meetsRegex(EMAIL_REGEX)]),
-    })
+    }),
+    additionalMetadata
   )
 
+const BooleanProperty = (config = {}, additionalMetadata={}) => Property(
+  PROPERTY_TYPES.BooleanProperty,
+  merge(config, {
+      isBoolean: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
+          maxNumber(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+)
+
+const UniqueId = (config = {}, additionalMetadata={}) =>
+  Property(
+    PROPERTY_TYPES.UniqueId,
+    {
+    ...config,
+    lazyLoadMethod: value => {
+      if (!value) {
+        return createUuid()
+      }
+      return value
+    },
+  }, additionalMetadata)
+
+
+
 module.exports = {
   Property,
   UniqueId,
@@ -250,4 +308,6 @@ module.exports = {
   NumberProperty,
   ObjectProperty,
   EmailProperty,
+  BooleanProperty,
+  createPropertyTitle,
 }

package/src/serialization.js

@@ -4,7 +4,10 @@ const SIZE_OF_GET = 'get'.length
 const IGNORABLE_KEYS = ['meta', 'functions']
 
 const _getValue = async value => {
-  if (!value) {
+  if (value === undefined) {
+    return null
+  }
+  if (value === null) {
     return null
   }
   const type = typeof value

package/src/utils.js

@@ -1,42 +1,52 @@
+const keyBy = require('lodash/keyBy')
+
 const HEX = 16
 const FOUR = 4
 const FIFTEEN = 15
 
-const toTitleCase = string => {
-  return `${string.slice(0, 1).toUpperCase()}${string.slice(1)}`
-}
-
-const createPropertyTitle = key => {
-  const goodName = toTitleCase(key)
-  return `get${goodName}`
-}
-
-const getCryptoRandomValues = () => {
+const getRandomValues = () => {
+  const array = new Uint8Array(1)
   if (typeof window !== 'undefined') {
+    if (window.crypto) {
+      return window.crypto.getRandomValues(array)
+    }
+    if (window.msCrypto) {
+      window.msCrypto.getRandomValues(array)
+    }
     return (window.crypto || window.msCrypto).getRandomValues
   }
 
-  return require('get-random-values')
+  return require('get-random-values')(array)
 }
 
 const createUuid = () => {
-  const getRandomValues = getCryptoRandomValues()
   // eslint-disable-next-line no-magic-numbers,require-unicode-regexp
-  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c =>
-    (
-      c ^
-      (getRandomValues(new Uint8Array(1))[0] & (FIFTEEN >> (c / FOUR)))
-    ).toString(HEX)
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => {
+    const value = getRandomValues()[0] & (FIFTEEN >> (c / FOUR))
+      return (c ^ value).toString(HEX)
+    }
   )
 }
 
+const toTitleCase = string => {
+  return `${string.slice(0, 1).toUpperCase()}${string.slice(1)}`
+}
+
 const loweredTitleCase = string => {
   return `${string.slice(0, 1).toLowerCase()}${string.slice(1)}`
 }
 
+const getObjToArray = array => {
+  const obj = keyBy(array)
+  return {
+    ...obj,
+    toArray: () => array,
+  }
+}
+
 module.exports = {
-  createUuid,
   loweredTitleCase,
-  createPropertyTitle,
   toTitleCase,
+  createUuid,
+  getObjToArray,
 }

package/src/validation.js

@@ -57,6 +57,15 @@ const arrayType = type => value => {
   }, undefined)
 }
 
+const multiplePropertiesMustMatch = (getKeyA, getKeyB, errorMessage='Properties do not match') => async (_, instance) => {
+  const keyA = await getKeyA(instance)
+  const keyB = await getKeyB(instance)
+  if (keyA !== keyB) {
+    return errorMessage
+  }
+  return undefined
+}
+
 const meetsRegex =
   (regex, flags, errorMessage = 'Format was invalid') =>
   value => {
@@ -193,6 +202,7 @@ const CONFIG_TO_VALIDATE_METHOD = {
   isNumber: _boolChoice(isNumber),
   isString: _boolChoice(isString),
   isArray: _boolChoice(isArray),
+  isBoolean: _boolChoice(isBoolean),
   choices,
 }
 
@@ -208,18 +218,18 @@ const createPropertyValidator = config => {
     : validators.includes(isRequired)
   const validator =
     validators.length > 0 ? aggregateValidator(validators) : emptyValidator
-  const _propertyValidator = async (value, instance, instanceData) => {
+  const _propertyValidator = async (value, instance, instanceData={}, options) => {
     if (!value && !isRequiredValue) {
       return []
     }
-    const errors = await validator(value, instance, instanceData)
+    const errors = await validator(value, instance, instanceData, options)
     return [...new Set(flatMap(errors))]
   }
   return _propertyValidator
 }
 
 const createModelValidator = (properties, modelValidators = []) => {
-  const _modelValidator = async instance => {
+  const _modelValidator = async (instance, options) => {
     if (!instance) {
       throw new Error(`Instance cannot be empty`)
     }
@@ -227,17 +237,17 @@ const createModelValidator = (properties, modelValidators = []) => {
       get(properties, 'functions.validators', {})
     )
     const instanceData = await instance.functions.toObj()
-    const data = await Promise.all(
+    const propertyValidationErrors = await Promise.all(
       keysAndFunctions.map(async ([key, validator]) => {
-        return [key, await validator(instance, instanceData)]
+        return [key, await validator(instance, instanceData, options)]
       })
     )
     const modelValidationErrors = (
       await Promise.all(
-        modelValidators.map(validator => validator(instance, instanceData))
+        modelValidators.map(validator => validator(instance, instanceData, options))
       )
     ).filter(x => x)
-    const propertyErrors = data
+    const propertyErrors = propertyValidationErrors
       .filter(([_, errors]) => Boolean(errors) && errors.length > 0)
       .reduce((acc, [key, errors]) => {
         return { ...acc, [key]: errors }
@@ -270,5 +280,6 @@ module.exports = {
   createModelValidator,
   arrayType,
   referenceTypeMatch,
+  multiplePropertiesMustMatch,
   TYPE_PRIMATIVES,
 }

package/test/src/models.test.js

@@ -2,7 +2,9 @@ const _ = require('lodash')
 const sinon = require('sinon')
 const assert = require('chai').assert
 const { Model } = require('../../src/models')
-const { Property } = require('../../src/properties')
+const { Property, TextProperty, ReferenceProperty } = require('../../src/properties')
+
+const TEST_MODEL_1 = Model('MyModel', )
 
 describe('/src/models.js', () => {
   describe('#Model()', () => {
@@ -12,11 +14,10 @@ describe('/src/models.js', () => {
         {},
         {
           instanceFunctions: {
-            func1: instance => () => {
-              console.log(instance)
+            func1: instance => {
               return instance.functions.func2()
             },
-            func2: instance => () => {
+            func2: instance => {
               return 'from instance func2'
             },
           },
@@ -27,6 +28,25 @@ describe('/src/models.js', () => {
       const expected = 'from instance func2'
       assert.deepEqual(actual, expected)
     })
+    it('should the clients arguments before the model is passed', () => {
+      const model = Model(
+        'ModelName',
+        {},
+        {
+          modelFunctions: {
+            func1: (model) => (input) => {
+              return `${input} ${model.func2()}`
+            },
+            func2: model => () => {
+              return 'from func2'
+            },
+          },
+        }
+      )
+      const actual = model.func1('hello')
+      const expected = 'hello from func2'
+      assert.deepEqual(actual, expected)
+    })
     it('should pass a functional model to the modelFunction by the time the function is called by a client', () => {
       const model = Model(
         'ModelName',
@@ -80,6 +100,16 @@ describe('/src/models.js', () => {
       })
     })
     describe('#create()', () => {
+      it('should have a meta.references.getTheReferenceId when the property has meta.getReferencedId and the key is theReference', () => {
+        const model = Model(
+          'ModelName',
+          {
+            theReference: ReferenceProperty(TEST_MODEL_1),
+          },
+        )
+        const instance = model.create({})
+        assert.isFunction(instance.meta.references.getTheReferenceId)
+      })
       it('should have an "getId" field when no primaryKey is passed', () => {
         const model = Model(
           'ModelName',
@@ -212,7 +242,7 @@ describe('/src/models.js', () => {
       })
       it('should use the value for Property.value when even if Property.defaultValue is set and a value is passed in', async () => {
         const input = {
-          myProperty: Property({
+          myProperty: Property('MyProperty', {
             value: 'value',
             defaultValue: 'default-value',
           }),
@@ -225,7 +255,7 @@ describe('/src/models.js', () => {
       })
       it('should use the value for Property.value when even if Property.defaultValue is not set and a value is passed in', async () => {
         const input = {
-          myProperty: Property({ value: 'value' }),
+          myProperty: Property('MyProperty', { value: 'value' }),
         }
         const model = Model('name', input)
         const instance = model.create({ myProperty: 'passed-in' })
@@ -235,7 +265,7 @@ describe('/src/models.js', () => {
       })
       it('should use the value for Property.defaultValue when Property.value is not set and no value is passed in', async () => {
         const input = {
-          myProperty: Property({ defaultValue: 'defaultValue' }),
+          myProperty: Property('MyProperty', { defaultValue: 'defaultValue' }),
         }
         const model = Model('name', input)
         const instance = model.create({})
@@ -245,7 +275,7 @@ describe('/src/models.js', () => {
       })
       it('should use the value for Property.defaultValue when Property.value is not set and null is passed as a value', async () => {
         const input = {
-          myProperty: Property({ defaultValue: 'defaultValue' }),
+          myProperty: Property('MyProperty', { defaultValue: 'defaultValue' }),
         }
         const model = Model('name', input)
         const instance = model.create({ myProperty: null })
@@ -255,8 +285,8 @@ describe('/src/models.js', () => {
       })
       it('should return a model with getId and getType for the provided valid keyToProperty', () => {
         const input = {
-          id: Property({ required: true }),
-          type: Property(),
+          id: Property('MyProperty', { required: true }),
+          type: Property('MyProperty'),
         }
         const model = Model('name', input)
         const actual = model.create({ id: 'my-id', type: 'my-type' })
@@ -265,8 +295,8 @@ describe('/src/models.js', () => {
       })
       it('should return a model where validate returns one error for id', async () => {
         const input = {
-          id: Property({ required: true }),
-          type: Property(),
+          id: Property('MyProperty', { required: true }),
+          type: Property('MyProperty'),
         }
         const model = Model('name', input)
         const instance = model.create({ type: 'my-type' })
@@ -274,6 +304,17 @@ describe('/src/models.js', () => {
         const expected = 1
         assert.equal(Object.values(actual).length, expected)
       })
+      it('should return a model where validate returns one error for the missing text property', async () => {
+        const input = {
+          id: Property('MyProperty', { required: true }),
+          text: TextProperty({required: true}),
+        }
+        const model = Model('name', input)
+        const instance = model.create({ id: 'my-id' })
+        const actual = await instance.functions.validate()
+        const expected = 1
+        assert.equal(Object.values(actual).length, expected)
+      })
     })
     it('should return an object with a function "create" when called once with valid data', () => {
       const actual = Model('name', {})
@@ -284,6 +325,20 @@ describe('/src/models.js', () => {
         Model('name', { model: 'weeee' }).create()
       })
     })
+    describe('#meta.references.getMyReferencedId()', () => {
+      it('should return the id from the ReferenceProperty', () => {
+        const model = Model(
+          'ModelName',
+          {
+            myReference: ReferenceProperty(TEST_MODEL_1),
+          },
+        )
+        const instance = model.create({ myReference: 'unit-test-id' })
+        const actual = instance.meta.references.getMyReferenceId()
+        const expected = 'unit-test-id'
+        assert.deepEqual(actual, expected)
+      })
+    })
     describe('#functions.getPrimaryKey()', () => {
       it('should return the id field when no primaryKey is passed', async () => {
         const model = Model(

package/test/src/properties.test.js

@@ -373,34 +373,34 @@ describe('/src/properties.js', () => {
   describe('#Property()', () => {
     it('should throw an exception if config.valueSelector is not a function but is set', () => {
       assert.throws(() => {
-        Property({ valueSelector: 'blah' })
+        Property('MyProperty', { valueSelector: 'blah' })
       })
     })
     it('should not throw an exception if config.valueSelector is a function', () => {
       assert.doesNotThrow(() => {
-        Property({ valueSelector: () => ({}) })
+        Property('MyProperty', { valueSelector: () => ({}) })
       })
     })
     describe('#createGetter()', () => {
       it('should return a function even if config.value is set to a value', () => {
-        const instance = Property({ value: 'my-value' })
+        const instance = Property('MyProperty', { 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 = Property({ value: 'my-value' })
+        const instance = Property('MyProperty', { 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 = Property()
+        const instance = Property('MyProperty')
         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 = Property()
+        const instance = Property('MyProperty')
         const actual = await instance.createGetter(() => 'my-value')()
         const expected = 'my-value'
         assert.deepEqual(actual, expected)