functional-models 1.0.1 → 1.0.5

package/.eslintignore

@@ -1,3 +1,4 @@
 dist/
 node_modules/
 test/
+features/

package/.github/workflows/feature.yml

@@ -0,0 +1,26 @@
+name: Feature Tests
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 15.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install dependencies
+        run: npm install
+      - name: Run Cucumber Tests
+        run: npm run feature-tests

package/.github/workflows/{ci.yml → ut.yml}

@@ -1,14 +1,13 @@
-name: CI
+name: Unit Tests
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     strategy:
@@ -23,11 +22,11 @@ jobs:
           node-version: ${{ matrix.node-version }}
       - name: Install dependencies
         run: npm install
-      - run: npm test
-      - run: npm run coverage 
+      - name: Run Unit Tests
+        run: npm test
+      - run: npm run coverage
 
       - name: Coveralls
         uses: coverallsapp/github-action@master
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
-

package/.prettierignore

@@ -1,4 +1,5 @@
 node_modules/
+*.json
 dist/
 *.html
 build

package/README.md

@@ -1,11 +1,12 @@
 # Functional Models
-![CI](https://github.com/monolithst/functional-models/actions/workflows/ci.yml/badge.svg)
+
+![Unit Tests](https://github.com/monolithst/functional-models/actions/workflows/ut.yml/badge.svg?branch=master)
+![Feature Tests](https://github.com/monolithst/functional-models/actions/workflows/feature.yml/badge.svg?branch=master)
 [![Coverage Status](https://coveralls.io/repos/github/monolithst/functional-models/badge.svg?branch=master)](https://coveralls.io/github/monolithst/functional-models?branch=master)
 
-Love functional javascript but still like composing objects/models? This is the library for you. 
+Love functional javascript but still like composing objects/models? This is the library for you.
 This library empowers the creation of pure JavaScript function based models that can be used on a client, a web frontend, and/or a backend all the same time. Use this library to create readable, read-only, models.
 
-
 ## Example Usage
 
     const {
@@ -51,5 +52,3 @@ This library empowers the creation of pure JavaScript function based models that
     console.log(sameTruck.getModel())  // 'F-150'
     console.log(sameTruck.getColor())  // 'White'
     console.log(sameTruck.getYear())   // 2013
-
-

package/features/model.feature

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

package/features/stepDefinitions/steps.js

@@ -0,0 +1,87 @@
+const assert = require('chai').assert
+const flatMap = require('lodash/flatMap')
+const { Given, When, Then } = require('@cucumber/cucumber')
+
+const { createModel, field } = require('../../index')
+
+const MODEL_DEFINITIONS = {
+  TestModel1: createModel({
+    name: field({ required: true }),
+    type: field({ required: true, isString: true }),
+    flag: field({ required: true, isNumber: true }),
+  }),
+}
+
+const MODEL_INPUT_VALUES = {
+  TestModel1a: {
+    name: 'my-name',
+    type: 1,
+    flag: '1',
+  },
+  TestModel1b: {
+    name: 'my-name',
+    type: 'a-type',
+    flag: 1,
+  },
+}
+
+const EXPECTED_FIELDS = {
+  TestModel1b: ['getName', 'getType', 'getFlag', 'meta', 'functions'],
+}
+
+Given(
+  'the {word} has been created, with {word} inputs provided',
+  function (modelDefinition, modelInputValues) {
+    const def = MODEL_DEFINITIONS[modelDefinition]
+    const input = MODEL_INPUT_VALUES[modelInputValues]
+    if (!def) {
+      throw new Error(`${modelDefinition} did not result in a definition`)
+    }
+    if (!input) {
+      throw new Error(`${modelInputValues} did not result in an input`)
+    }
+    this.instance = def(input)
+  }
+)
+
+When('functions.validate is called', function () {
+  return this.instance.functions.validate.model().then(x => {
+    this.errors = x
+  })
+})
+
+Then('an array of {int} errors is shown', function (errorCount) {
+  const errors = flatMap(Object.values(this.errors))
+  if (errors.length !== errorCount) {
+    console.error(this.errors)
+  }
+  assert.equal(errors.length, errorCount)
+})
+
+Given('{word} is used', function (modelDefinition) {
+  const def = MODEL_DEFINITIONS[modelDefinition]
+  if (!def) {
+    throw new Error(`${modelDefinition} did not result in a definition`)
+  }
+  this.modelDefinition = def
+})
+
+When('{word} data is inserted', function (modelInputValues) {
+  const input = MODEL_INPUT_VALUES[modelInputValues]
+  if (!input) {
+    throw new Error(`${modelInputValues} did not result in an input`)
+  }
+  this.instance = this.modelDefinition(input)
+})
+
+Then('{word} expected fields are found', function (fields) {
+  const propertyArray = EXPECTED_FIELDS[fields]
+  if (!propertyArray) {
+    throw new Error(`${fields} did not result in fields`)
+  }
+  propertyArray.forEach(key => {
+    if (!(key in this.instance)) {
+      throw new Error(`Did not find ${key} in model`)
+    }
+  })
+})

package/features/validation.feature

@@ -0,0 +1,12 @@
+Feature: Validation
+
+  Scenario: Creating TestModel1 with required arguments but not having them.
+    Given the TestModel1 has been created, with TestModel1a inputs provided
+    When functions.validate is called
+    Then an array of 2 errors is shown
+
+  Scenario: Creating TestModel1 with required arguments and having them.
+    Given the TestModel1 has been created, with TestModel1b inputs provided
+    When functions.validate is called
+    Then an array of 0 errors is shown
+

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "functional-models",
-  "version": "1.0.1",
+  "version": "1.0.5",
   "description": "A library for creating JavaScript function based models.",
   "main": "index.js",
   "scripts": {
     "test": "nyc --all mocha --recursive ./test/**/*.test.js",
+    "feature-tests": "./node_modules/@cucumber/cucumber/bin/cucumber-js",
     "coverage": "nyc --all --reporter=lcov npm test"
   },
   "repository": {
@@ -26,11 +27,16 @@
   },
   "homepage": "https://github.com/monolithst/functional-models#readme",
   "nyc": {
-    "all": true
+    "all": true,
+    "exclude": [
+      "features/stepDefinitions/*",
+      "test/*"
+    ]
   },
   "devDependencies": {
     "babel-eslint": "^10.1.0",
     "chai": "^4.3.0",
+    "cucumber": "^7.0.0-rc.0",
     "eslint": "^7.19.0",
     "eslint-config-prettier": "^7.2.0",
     "eslint-plugin-functional": "^3.2.1",
@@ -42,6 +48,7 @@
   },
   "dependencies": {
     "get-random-values": "^1.2.2",
-    "lazy-property": "^1.0.0"
+    "lazy-property": "^1.0.0",
+    "lodash": "^4.17.21"
   }
 }

package/src/fields.js

@@ -0,0 +1,106 @@
+const identity = require('lodash/identity')
+const { createFieldValidator } = require('./validation')
+const { createUuid } = require('./utils')
+const { lazyValue } = require('./lazy')
+
+const field = (config = {}) => {
+  const value = config.value || undefined
+  const defaultValue = config.defaultValue || undefined
+  const lazyLoadMethod = config.lazyLoadMethod || false
+  const valueSelector = config.valueSelector || identity
+  if (typeof valueSelector !== 'function') {
+    throw new Error(`valueSelector must be a function`)
+  }
+
+  return {
+    createGetter: instanceValue => {
+      if (value !== undefined) {
+        return () => value
+      }
+      if (
+        defaultValue !== undefined &&
+        (instanceValue === null || instanceValue === undefined)
+      ) {
+        return () => defaultValue
+      }
+      const method = lazyLoadMethod
+        ? lazyValue(lazyLoadMethod)
+        : typeof instanceValue === 'function'
+        ? instanceValue
+        : () => instanceValue
+      return async () => {
+        return valueSelector(await method(instanceValue))
+      }
+    },
+    getValidator: valueGetter => {
+      return async () => {
+        return createFieldValidator(config)(await valueGetter())
+      }
+    },
+  }
+}
+
+const uniqueId = config =>
+  field({
+    ...config,
+    lazyLoadMethod: value => {
+      if (!value) {
+        return createUuid()
+      }
+      return value
+    },
+  })
+
+const dateField = config =>
+  field({
+    ...config,
+    lazyLoadMethod: value => {
+      if (!value && config.autoNow) {
+        return new Date()
+      }
+      return value
+    },
+  })
+
+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)
+      }
+      return _getId(smartObj)
+    },
+  })
+}
+
+module.exports = {
+  field,
+  uniqueId,
+  dateField,
+  referenceField,
+}

package/src/index.js

@@ -1,6 +1,6 @@
 module.exports = {
-  ...require('./dates'),
-  ...require('./lazy'),
-  ...require('./objects'),
-  ...require('./properties'),
+  ...require('./fields'),
+  ...require('./models'),
+  validation: require('./validation'),
+  serialization: require('./serialization'),
 }

package/src/lazy.js

@@ -1,16 +1,19 @@
-const { lazyValue, createPropertyTitle } = require('./utils')
+const lazyValue = method => {
+  /* 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
+    }
 
-const lazyProperty = (key, method, { selector = null } = {}) => {
-  const lazy = lazyValue(method)
-  const propertyKey = createPropertyTitle(key)
-  return {
-    [propertyKey]: async () => {
-      const value = await lazy()
-      return selector ? selector(value) : value
-    },
+    return value
   }
+  /* eslint-enable functional/no-let */
 }
 
 module.exports = {
-  lazyProperty,
+  lazyValue,
 }

package/src/models.js

@@ -0,0 +1,55 @@
+const merge = require('lodash/merge')
+const get = require('lodash/get')
+const { toJson } = require('./serialization')
+const { createPropertyTitle } = require('./utils')
+const { createModelValidator } = require('./validation')
+
+const SYSTEM_KEYS = ['meta', 'functions']
+
+const PROTECTED_KEYS = ['model']
+
+const createModel = 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 nonSystemProperties = Object.entries(keyToField).filter(
+    ([key, _]) => !(key in SYSTEM_KEYS)
+  )
+
+  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,
+          },
+        },
+      }
+      return merge(acc, fleshedOutField)
+    }, {})
+    const allUserData = merge(systemProperties, loadedInternals)
+    const internalFunctions = {
+      functions: {
+        toJson: toJson(loadedInternals),
+        validate: {
+          model: createModelValidator(loadedInternals),
+        },
+      },
+    }
+    return merge(allUserData, internalFunctions)
+  }
+}
+
+module.exports = {
+  createModel,
+}

package/src/utils.js

@@ -11,22 +11,6 @@ const createPropertyTitle = key => {
   return `get${goodName}`
 }
 
-const lazyValue = method => {
-  /* eslint-disable functional/no-let */
-  let value = undefined
-  let called = false
-  return async () => {
-    if (!called) {
-      value = await method()
-      // eslint-disable-next-line require-atomic-updates
-      called = true
-    }
-
-    return value
-  }
-  /* eslint-enable functional/no-let */
-}
-
 const getCryptoRandomValues = () => {
   if (typeof window !== 'undefined') {
     return (window.crypto || window.msCrypto).getRandomValues
@@ -53,6 +37,6 @@ const loweredTitleCase = string => {
 module.exports = {
   createUuid,
   loweredTitleCase,
-  lazyValue,
   createPropertyTitle,
+  toTitleCase,
 }

package/src/validation.js

@@ -0,0 +1,173 @@
+const isEmpty = require('lodash/isEmpty')
+const flatMap = require('lodash/flatMap')
+const get = require('lodash/get')
+
+const _trueOrError = (method, error) => value => {
+  if (method(value) === false) {
+    return error
+  }
+  return undefined
+}
+
+const _typeOrError = (type, errorMessage) => value => {
+  if (typeof value !== type) {
+    return errorMessage
+  }
+  return undefined
+}
+
+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 isBoolean = isType('boolean')
+const isString = isType('string')
+
+const meetsRegex =
+  (regex, flags, errorMessage = 'Format was invalid') =>
+  value => {
+    const reg = new RegExp(regex, flags)
+    return _trueOrError(v => reg.test(v), errorMessage)(value)
+  }
+
+const choices = choiceArray => value => {
+  if (choiceArray.includes(value) === false) {
+    return 'Not a valid choice'
+  }
+  return undefined
+}
+
+const isRequired = value => {
+  if (value === true || value === false) {
+    return undefined
+  }
+  if (isNumber(value) === undefined) {
+    return undefined
+  }
+  return isEmpty(value) ? 'A value is required' : undefined
+}
+
+const maxNumber = max => value => {
+  const numberError = isNumber(value)
+  if (numberError) {
+    return numberError
+  }
+  if (value > max) {
+    return `The maximum is ${max}`
+  }
+  return undefined
+}
+
+const minNumber = min => value => {
+  const numberError = isNumber(value)
+  if (numberError) {
+    return numberError
+  }
+  if (value < min) {
+    return `The minimum is ${min}`
+  }
+  return undefined
+}
+
+const maxTextLength = max => value => {
+  const stringError = isString(value)
+  if (stringError) {
+    return stringError
+  }
+  if (value.length > max) {
+    return `The maximum length is ${max}`
+  }
+  return undefined
+}
+
+const minTextLength = min => value => {
+  const stringError = isString(value)
+  if (stringError) {
+    return stringError
+  }
+  if (value.length < min) {
+    return `The minimum length is ${min}`
+  }
+  return undefined
+}
+
+const aggregateValidator = methodOrMethods => async value => {
+  const toDo = Array.isArray(methodOrMethods)
+    ? methodOrMethods
+    : [methodOrMethods]
+  const values = await Promise.all(
+    toDo.map(method => {
+      return method(value)
+    })
+  )
+  return values.filter(x => x)
+}
+
+const emptyValidator = () => []
+
+const _boolChoice = method => value => {
+  return value ? method : undefined
+}
+
+const CONFIG_TO_VALIDATE_METHOD = {
+  required: _boolChoice(isRequired),
+  isInteger: _boolChoice(isInteger),
+  isNumber: _boolChoice(isNumber),
+  isString: _boolChoice(isString),
+}
+
+const createFieldValidator = config => {
+  const validators = [
+    ...Object.entries(config).map(([key, value]) => {
+      return (CONFIG_TO_VALIDATE_METHOD[key] || (() => undefined))(value)
+    }),
+    ...(config.validators ? config.validators : []),
+  ].filter(x => x)
+  const validator =
+    validators.length > 0 ? aggregateValidator(validators) : emptyValidator
+  return async value => {
+    const errors = await validator(value)
+    return 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 }
+    }, {})
+}
+
+module.exports = {
+  isNumber,
+  isBoolean,
+  isString,
+  isInteger,
+  isType,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  emptyValidator,
+  createFieldValidator,
+  createModelValidator,
+}