functional-models 1.0.8 → 1.0.14

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,16 @@ 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

@@ -1,52 +1,52 @@
-Feature: Array Fields
+Feature: Array Property
 
-  Scenario: A model that has an array field is created holding an array of integers and is checked and validated
+  Scenario: A model that has an array property is created holding an array of integers and is checked and validated
     Given ArrayModel1 model is used
     When ArrayModelData1 data is inserted
-    Then the getArrayField field is called on the model
+    Then the getArrayProperty property is called on the model
     Then the array values match
       | array | [1,2,3,4,5]|
     Then functions.validate is called
     Then an array of 0 errors is shown
 
-  Scenario: A model that has an array field but has a non-array inserted into it fails validation
+  Scenario: A model that has an array property but has a non-array inserted into it fails validation
     Given ArrayModel1 model is used
     When ArrayModelData2 data is inserted
-    Then the getArrayField field is called on the model
+    Then the getArrayProperty property is called on the model
     Then functions.validate is called
     Then an array of 1 errors is shown
 
-  Scenario: A model that has an array field for integers but an array of strings is inserted into it, it should fail validation
+  Scenario: A model that has an array property for integers but an array of strings is inserted into it, it should fail validation
     Given ArrayModel1 model is used
     When ArrayModelData3 data is inserted
-    Then the getArrayField field is called on the model
+    Then the getArrayProperty property is called on the model
     Then functions.validate is called
     Then an array of 1 errors is shown
 
-  Scenario: A model that has an array field that has mixed values it should not fail validation.
+  Scenario: A model that has an array property that has mixed values it should not fail validation.
     Given ArrayModel2 model is used
     When ArrayModelData4 data is inserted
-    Then the getArrayField field is called on the model
+    Then the getArrayProperty property 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 field that has mixed values it should not fail validation.
+  Scenario: A model that uses the arrayProperty property that has mixed values it should not fail validation.
     Given ArrayModel3 model is used
     When ArrayModelData4 data is inserted
-    Then the getArrayField field is called on the model
+    Then the getArrayProperty property 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.
+  Scenario: A model that uses the arrayProperty 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 the getArrayProperty property 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
+  Scenario: A model that uses the arrayProperty 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 the getArrayProperty property is called on the model
     Then functions.validate is called
     Then an array of 1 errors is shown

package/features/model.feature

@@ -1,7 +1,7 @@
 Feature: Models
 
-  Scenario: A Model With a 4 fields
+  Scenario: A Model With 4 properties
     Given TestModel1 model is used
     When TestModel1b data is inserted
-    Then TestModel1b expected fields are found
+    Then TestModel1b expected property is found
 

package/features/stepDefinitions/steps.js

@@ -1,28 +1,28 @@
 const assert = require('chai').assert
 const flatMap = require('lodash/flatMap')
 const { Given, When, Then } = require('@cucumber/cucumber')
-const { createModel, field, arrayField, validation } = require('../../index')
+const { Model, Property, ArrayProperty, validation } = require('../../index')
 
 const MODEL_DEFINITIONS = {
-  TestModel1: createModel({
-    name: field({ required: true }),
-    type: field({ required: true, isString: true }),
-    flag: field({ required: true, isNumber: true }),
+  TestModel1: Model('TestModel1', {
+    name: Property({ required: true }),
+    type: Property({ required: true, isString: true }),
+    flag: Property({ required: true, isNumber: true }),
   }),
-  ArrayModel1: createModel({
-    arrayField: field({
+  ArrayModel1: Model('ArrayModel1', {
+    ArrayProperty: Property({
       isArray: true,
       validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],
     }),
   }),
-  ArrayModel2: createModel({
-    arrayField: field({ isArray: true }),
+  ArrayModel2: Model('ArrayModel2', {
+    ArrayProperty: Property({ isArray: true }),
   }),
-  ArrayModel3: createModel({
-    arrayField: arrayField({}),
+  ArrayModel3: Model('ArrayModel3', {
+    ArrayProperty: ArrayProperty({}),
   }),
-  ArrayModel4: createModel({
-    arrayField: arrayField({
+  ArrayModel4: Model('ArrayModel4', {
+    ArrayProperty: ArrayProperty({
       choices: [4, 5, 6],
       validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],
     }),
@@ -41,22 +41,22 @@ const MODEL_INPUT_VALUES = {
     flag: 1,
   },
   ArrayModelData1: {
-    arrayField: [1, 2, 3, 4, 5],
+    ArrayProperty: [1, 2, 3, 4, 5],
   },
   ArrayModelData2: {
-    arrayField: 'a-string',
+    ArrayProperty: 'a-string',
   },
   ArrayModelData3: {
-    arrayField: ['a-string', 'a-string2'],
+    ArrayProperty: ['a-string', 'a-string2'],
   },
   ArrayModelData4: {
-    arrayField: ['a-string', 1, {}, true],
+    ArrayProperty: ['a-string', 1, {}, true],
   },
   ArrayModelData5: {
-    arrayField: [4, 5, 5, 5, 6],
+    ArrayProperty: [4, 5, 5, 5, 6],
   },
   ArrayModelData6: {
-    arrayField: [4, 5, 5, 5, 6, 1],
+    ArrayProperty: [4, 5, 5, 5, 6, 1],
   },
 }
 
@@ -75,7 +75,7 @@ Given(
     if (!input) {
       throw new Error(`${modelInputValues} did not result in an input`)
     }
-    this.instance = def(input)
+    this.instance = def.create(input)
   }
 )
 
@@ -106,13 +106,13 @@ When('{word} data is inserted', function (modelInputValues) {
   if (!input) {
     throw new Error(`${modelInputValues} did not result in an input`)
   }
-  this.instance = this.modelDefinition(input)
+  this.instance = this.modelDefinition.create(input)
 })
 
-Then('{word} expected fields are found', function (fields) {
-  const propertyArray = EXPECTED_FIELDS[fields]
+Then('{word} expected property is found', function (properties) {
+  const propertyArray = EXPECTED_FIELDS[properties]
   if (!propertyArray) {
-    throw new Error(`${fields} did not result in fields`)
+    throw new Error(`${properties} did not result in properties`)
   }
   propertyArray.forEach(key => {
     if (!(key in this.instance)) {
@@ -121,8 +121,8 @@ Then('{word} expected fields are found', function (fields) {
   })
 })
 
-Then('the {word} field is called on the model', function (field) {
-  return this.instance[field]().then(result => {
+Then('the {word} property is called on the model', function (property) {
+  return this.instance[property]().then(result => {
     this.results = result
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functional-models",
-  "version": "1.0.8",
+  "version": "1.0.14",
   "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/index.js

@@ -1,5 +1,5 @@
 module.exports = {
-  ...require('./fields'),
+  ...require('./properties'),
   ...require('./models'),
   validation: require('./validation'),
   serialization: require('./serialization'),

package/src/models.js

@@ -1,55 +1,104 @@
 const merge = require('lodash/merge')
-const get = require('lodash/get')
-const { toJson } = require('./serialization')
+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 Model = (
+  modelName,
+  keyToProperty,
+  modelExtensions = {},
+  { instanceCreatedCallback = null } = {}
+) => {
+  /*
+   * This non-functional approach is specifically used to
+   * allow instances to be able to refer back to its parent without
+   * having to duplicate it for every instance.
+   * This is set at the very end and returned, so it can be referenced
+   * throughout instance methods.
+   */
+  // eslint-disable-next-line functional/no-let
+  let model = null
   PROTECTED_KEYS.forEach(key => {
-    if (key in keyToField) {
+    if (key in keyToProperty) {
       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 instanceProperties = Object.entries(keyToProperty).filter(
+    ([key, _]) => MODEL_DEF_KEYS.includes(key) === false
+  )
+  const specialProperties1 = Object.entries(keyToProperty).filter(([key, _]) =>
+    MODEL_DEF_KEYS.includes(key)
+  )
+  const properties = instanceProperties.reduce((acc, [key, property]) => {
+    return merge(acc, { [key]: property })
   }, {})
-  const nonSystemProperties = Object.entries(keyToField).filter(
-    ([key, _]) => !(key in SYSTEM_KEYS)
+  const specialProperties = specialProperties1.reduce(
+    (acc, [key, property]) => {
+      return merge(acc, { [key]: property })
+    },
+    {}
   )
 
-  return instanceValues => {
-    const loadedInternals = nonSystemProperties.reduce((acc, [key, field]) => {
-      const fieldGetter = field.createGetter(instanceValues[key])
-      const fieldValidator = field.getValidator(fieldGetter)
-      const getFieldKey = createPropertyTitle(key)
-      const fleshedOutField = {
-        [getFieldKey]: fieldGetter,
-        functions: {
-          validate: {
-            [key]: fieldValidator,
-          },
-        },
+  const create = (instanceValues = {}) => {
+    const specialInstanceProperties1 = MODEL_DEF_KEYS.reduce((acc, key) => {
+      if (key in instanceValues) {
+        return { ...acc, [key]: instanceValues[key] }
       }
-      return merge(acc, fleshedOutField)
+      return acc
     }, {})
-    const allUserData = merge(systemProperties, loadedInternals)
-    const internalFunctions = {
+    const loadedInternals = instanceProperties.reduce(
+      (acc, [key, property]) => {
+        const propertyGetter = property.createGetter(instanceValues[key])
+        const propertyValidator = property.getValidator(propertyGetter)
+        const getPropertyKey = createPropertyTitle(key)
+        const fleshedOutInstanceProperties = {
+          [getPropertyKey]: propertyGetter,
+          functions: {
+            validate: {
+              [key]: propertyValidator,
+            },
+          },
+        }
+        return merge(acc, fleshedOutInstanceProperties)
+      },
+      {}
+    )
+    const frameworkProperties = {
+      meta: {
+        getModel: () => model,
+      },
       functions: {
-        toJson: toJson(loadedInternals),
+        toObj: toObj(loadedInternals),
         validate: {
           model: createModelValidator(loadedInternals),
         },
       },
     }
-    return merge(allUserData, internalFunctions)
+    const instance = merge(
+      {},
+      loadedInternals,
+      specialProperties,
+      frameworkProperties,
+      specialInstanceProperties1
+    )
+    if (instanceCreatedCallback) {
+      instanceCreatedCallback(instance)
+    }
+    return instance
   }
+
+  // This sets the model that is used by the instances later.
+  model = merge({}, modelExtensions, {
+    create,
+    getName: () => modelName,
+    getProperties: () => properties,
+  })
+  return model
 }
 
 module.exports = {
-  createModel,
+  Model,
 }

package/src/{fields.js → properties.js}

@@ -1,13 +1,15 @@
 const identity = require('lodash/identity')
+const isFunction = require('lodash/isFunction')
 const merge = require('lodash/merge')
 const {
-  createFieldValidator,
+  createPropertyValidator,
   emptyValidator,
   maxTextLength,
   minTextLength,
   minNumber,
   maxNumber,
   isType,
+  referenceTypeMatch,
   meetsRegex,
 } = require('./validation')
 const { createUuid } = require('./utils')
@@ -23,7 +25,7 @@ const _getValidatorFromConfigElseEmpty = (config, key, validatorGetter) => {
   return emptyValidator
 }
 
-const field = (config = {}) => {
+const Property = (config = {}, additionalMetadata = {}) => {
   const value = config.value || undefined
   const defaultValue = config.defaultValue || undefined
   const lazyLoadMethod = config.lazyLoadMethod || false
@@ -33,6 +35,7 @@ const field = (config = {}) => {
   }
 
   return {
+    ...additionalMetadata,
     createGetter: instanceValue => {
       if (value !== undefined) {
         return () => value
@@ -53,15 +56,17 @@ const field = (config = {}) => {
       }
     },
     getValidator: valueGetter => {
-      return async () => {
-        return createFieldValidator(config)(await valueGetter())
+      const validator = createPropertyValidator(config)
+      const _propertyValidatorWrapper = async () => {
+        return validator(await valueGetter())
       }
+      return _propertyValidatorWrapper
     },
   }
 }
 
-const uniqueId = config =>
-  field({
+const UniqueId = (config = {}) =>
+  Property({
     ...config,
     lazyLoadMethod: value => {
       if (!value) {
@@ -71,8 +76,8 @@ const uniqueId = config =>
     },
   })
 
-const dateField = config =>
-  field({
+const DateProperty = (config = {}) =>
+  Property({
     ...config,
     lazyLoadMethod: value => {
       if (!value && config.autoNow) {
@@ -82,58 +87,85 @@ const dateField = config =>
     },
   })
 
-const referenceField = config => {
-  return field({
-    ...config,
-    lazyLoadMethod: async smartObj => {
-      const _getId = () => {
-        if (!smartObj) {
-          return null
-        }
-        return smartObj && smartObj.id
-          ? smartObj.id
-          : smartObj.getId
-          ? smartObj.getId()
-          : smartObj
-      }
-      const _getSmartObjReturn = objToUse => {
-        return {
-          ...objToUse,
-          functions: {
-            ...(objToUse.functions ? objToUse.functions : {}),
-            toJson: _getId,
-          },
-        }
-      }
-      const valueIsSmartObj = smartObj && smartObj.functions
-      if (valueIsSmartObj) {
-        return _getSmartObjReturn(smartObj)
-      }
-      if (config.fetcher) {
-        const obj = await config.fetcher(smartObj)
-        return _getSmartObjReturn(obj)
+const ReferenceProperty = (model, config = {}) => {
+  if (!model) {
+    throw new Error('Must include the referenced model')
+  }
+
+  const _getModel = () => {
+    if (isFunction(model)) {
+      return model()
+    }
+    return model
+  }
+
+  const validators = [...(config.validators || []), referenceTypeMatch(model)]
+
+  const lazyLoadMethod = async instanceValues => {
+    const _getId = () => {
+      if (!instanceValues) {
+        return null
       }
-      return _getId(smartObj)
-    },
-  })
+      return instanceValues && instanceValues.id
+        ? instanceValues.id
+        : instanceValues.getId
+        ? instanceValues.getId()
+        : instanceValues
+    }
+    const valueIsModelInstance =
+      Boolean(instanceValues) && Boolean(instanceValues.functions)
+
+    const _getInstanceReturn = objToUse => {
+      const instance = valueIsModelInstance
+        ? objToUse
+        : _getModel().create(objToUse)
+      return merge({}, instance, {
+        functions: {
+          toObj: _getId,
+        },
+      })
+    }
+
+    if (valueIsModelInstance) {
+      return _getInstanceReturn(instanceValues)
+    }
+    if (config.fetcher) {
+      const id = await _getId()
+      const obj = await config.fetcher(_getModel(), id)
+      return _getInstanceReturn(obj)
+    }
+    return _getId(instanceValues)
+  }
+
+  return Property(
+    merge({}, config, {
+      validators,
+      lazyLoadMethod,
+    }),
+    {
+      meta: {
+        getReferencedModel: _getModel,
+      },
+    }
+  )
 }
 
-const arrayField = (config = {}) =>
-  field({
+const ArrayProperty = (config = {}) =>
+  Property({
     defaultValue: [],
     ...config,
     isArray: true,
   })
 
-const objectField = (config = {}) =>
-  field(
+const ObjectProperty = (config = {}) =>
+  Property(
     merge(config, {
       validators: [isType('object')],
     })
   )
 
-const textField = (config = {}) =>
-  field(
+const TextProperty = (config = {}) =>
+  Property(
     merge(config, {
       isString: true,
       validators: [
@@ -147,8 +179,8 @@ const textField = (config = {}) =>
     })
   )
 
-const integerField = (config = {}) =>
-  field(
+const IntegerProperty = (config = {}) =>
+  Property(
     merge(config, {
       isInteger: true,
       validators: [
@@ -162,8 +194,8 @@ const integerField = (config = {}) =>
     })
   )
 
-const numberField = (config = {}) =>
-  field(
+const NumberProperty = (config = {}) =>
+  Property(
     merge(config, {
       isNumber: true,
       validators: [
@@ -177,30 +209,30 @@ const numberField = (config = {}) =>
     })
   )
 
-const constantValueField = (value, config = {}) =>
-  textField(
+const ConstantValueProperty = (value, config = {}) =>
+  TextProperty(
     merge(config, {
       value,
     })
   )
 
-const emailField = (config = {}) =>
-  textField(
+const EmailProperty = (config = {}) =>
+  TextProperty(
     merge(config, {
       validators: [meetsRegex(EMAIL_REGEX)],
     })
   )
 
 module.exports = {
-  field,
-  uniqueId,
-  dateField,
-  arrayField,
-  referenceField,
-  integerField,
-  textField,
-  constantValueField,
-  numberField,
-  objectField,
-  emailField,
+  Property,
+  UniqueId,
+  DateProperty,
+  ArrayProperty,
+  ReferenceProperty,
+  IntegerProperty,
+  TextProperty,
+  ConstantValueProperty,
+  NumberProperty,
+  ObjectProperty,
+  EmailProperty,
 }