functional-models 1.0.25 → 1.1.0

package/src/validation.ts

@@ -0,0 +1,390 @@
+import isEmpty from 'lodash/isEmpty'
+import merge from 'lodash/merge'
+import flatMap from 'lodash/flatMap'
+import {
+  FunctionalModel,
+  ModelInstance,
+  Model,
+  ModelComponentValidator,
+  PropertyValidatorComponent,
+  PropertyValidatorComponentType,
+  PropertyValidatorComponentSync,
+  PropertyValidatorComponentTypeAdvanced,
+  PropertyValidator,
+  PropertyConfig,
+  MaybeFunction,
+  PropertyValidators,
+  ValueGetter,
+  Arrayable,
+  FunctionalType,
+  ModelErrors,
+} from './interfaces'
+
+const TYPE_PRIMITIVES = {
+  boolean: 'boolean',
+  string: 'string',
+  object: 'object',
+  number: 'number',
+  integer: 'integer',
+}
+
+const filterEmpty = <T>(
+  array: readonly (T | undefined | null)[]
+): readonly T[] => {
+  return array.filter(x => x) as readonly T[]
+}
+
+const _trueOrError =
+  (method: Function, error: string): PropertyValidatorComponentSync =>
+  (value: any) => {
+    if (method(value) === false) {
+      return error
+    }
+    return undefined
+  }
+
+const _typeOrError =
+  (type: string, errorMessage: string): PropertyValidatorComponentSync =>
+  (value: any) => {
+    if (typeof value !== type) {
+      return errorMessage
+    }
+    return undefined
+  }
+
+const isType =
+  (type: string): PropertyValidatorComponentSync =>
+  (value: any) => {
+    // @ts-ignore
+    return _typeOrError(type, `Must be a ${type}`)(value)
+  }
+const isNumber = isType('number')
+const isInteger = _trueOrError(Number.isInteger, 'Must be an integer')
+
+const isBoolean = isType('boolean')
+const isString = isType('string')
+const isArray = _trueOrError(
+  (v: any) => Array.isArray(v),
+  'Value is not an array'
+)
+
+const PRIMITIVE_TO_SPECIAL_TYPE_VALIDATOR = {
+  [TYPE_PRIMITIVES.boolean]: isBoolean,
+  [TYPE_PRIMITIVES.string]: isString,
+  [TYPE_PRIMITIVES.integer]: isInteger,
+  [TYPE_PRIMITIVES.number]: isNumber,
+}
+
+const arrayType =
+  (type: string): PropertyValidatorComponentSync =>
+  (value: Arrayable<FunctionalType>) => {
+    // @ts-ignore
+    const arrayError = isArray(value)
+    if (arrayError) {
+      return arrayError
+    }
+    const validator = PRIMITIVE_TO_SPECIAL_TYPE_VALIDATOR[type] || isType(type)
+    return (value as readonly []).reduce(
+      (acc: string | undefined, v: FunctionalType) => {
+        if (acc) {
+          return acc
+        }
+        // @ts-ignore
+        return validator(v)
+      },
+      undefined
+    )
+  }
+
+const meetsRegex =
+  (
+    regex: string | RegExp,
+    flags?: string,
+    errorMessage: string = 'Format was invalid'
+  ): PropertyValidatorComponentSync =>
+  (value: FunctionalType) => {
+    const reg = new RegExp(regex, flags)
+    // @ts-ignore
+    return _trueOrError((v: string) => reg.test(v), errorMessage)(value)
+  }
+
+const choices =
+  (choiceArray: readonly FunctionalType[]): PropertyValidatorComponentSync =>
+  (value: Arrayable<FunctionalType>) => {
+    if (Array.isArray(value)) {
+      const bad = value.find(v => !choiceArray.includes(v))
+      if (bad) {
+        return `${bad} is not a valid choice`
+      }
+    } else {
+      if (!choiceArray.includes(value as FunctionalType)) {
+        return `${value} is not a valid choice`
+      }
+    }
+    return undefined
+  }
+
+const isDate: PropertyValidatorComponentType<Date> = (value: Date) => {
+  if (!value) {
+    return 'Date value is empty'
+  }
+  if (!value.toISOString) {
+    return 'Value is not a date'
+  }
+  return undefined
+}
+
+const isRequired: PropertyValidatorComponentSync = (value?: any) => {
+  if (value === true || value === false) {
+    return undefined
+  }
+  // @ts-ignore
+  if (isNumber(value) === undefined) {
+    return undefined
+  }
+  const empty = isEmpty(value)
+  if (empty) {
+    // @ts-ignore
+    if (isDate(value)) {
+      return 'A value is required'
+    }
+  }
+  return undefined
+}
+
+const maxNumber =
+  (max: Number): PropertyValidatorComponentType<number> =>
+  (value: number) => {
+    // @ts-ignore
+    const numberError = isNumber(value)
+    if (numberError) {
+      return numberError
+    }
+    if (value && value > max) {
+      return `The maximum is ${max}`
+    }
+    return undefined
+  }
+
+const minNumber =
+  (min: Number): PropertyValidatorComponentType<number> =>
+  (value: Number) => {
+    // @ts-ignore
+    const numberError = isNumber(value)
+    if (numberError) {
+      return numberError
+    }
+    if (value && value < min) {
+      return `The minimum is ${min}`
+    }
+    return undefined
+  }
+
+const maxTextLength =
+  (max: Number): PropertyValidatorComponentType<string> =>
+  (value: string) => {
+    // @ts-ignore
+    const stringError = isString(value)
+    if (stringError) {
+      return stringError
+    }
+    if (value && value.length > max) {
+      return `The maximum length is ${max}`
+    }
+    return undefined
+  }
+
+const minTextLength =
+  (min: Number): PropertyValidatorComponentType<string> =>
+  (value: string) => {
+    // @ts-ignore
+    const stringError = isString(value)
+    if (stringError) {
+      return stringError
+    }
+    if (value && value.length < min) {
+      return `The minimum length is ${min}`
+    }
+    return undefined
+  }
+
+const referenceTypeMatch = <TModel extends FunctionalModel>(
+  referencedModel: MaybeFunction<Model<TModel>>
+): PropertyValidatorComponentTypeAdvanced<ModelInstance<TModel>, TModel> => {
+  return (value?: ModelInstance<TModel>) => {
+    if (!value) {
+      return 'Must include a value'
+    }
+    // This needs to stay here, as it delays the creation long enough for
+    // self referencing types.
+    const model =
+      typeof referencedModel === 'function'
+        ? referencedModel()
+        : referencedModel
+    // Assumption: By the time this is received, value === a model instance.
+    const eModel = model.getName()
+    const aModel = value.getModel().getName()
+    if (eModel !== aModel) {
+      return `Model should be ${eModel} instead, received ${aModel}`
+    }
+    return undefined
+  }
+}
+
+const aggregateValidator = (
+  value: any,
+  methodOrMethods:
+    | PropertyValidatorComponent
+    | readonly PropertyValidatorComponent[]
+) => {
+  const toDo = Array.isArray(methodOrMethods)
+    ? methodOrMethods
+    : [methodOrMethods]
+
+  const _aggregativeValidator: PropertyValidator = async (
+    instance: ModelInstance<any>,
+    instanceData: FunctionalModel
+  ) => {
+    const values = await Promise.all(
+      toDo.map(method => {
+        return method(value, instance, instanceData)
+      })
+    )
+    return filterEmpty(values)
+  }
+  return _aggregativeValidator
+}
+
+const emptyValidator: PropertyValidatorComponentSync = () => undefined
+
+const _boolChoice =
+  (method: (configValue: any) => PropertyValidatorComponentSync) =>
+  (configValue: any) => {
+    const func = method(configValue)
+    const validatorWrapper: PropertyValidatorComponentSync = (
+      value: any,
+      modelInstance: ModelInstance<any>,
+      modelData: FunctionalModel
+    ) => {
+      return func(value, modelInstance, modelData)
+    }
+    return validatorWrapper
+  }
+
+type MethodConfigDict = {
+  readonly [s: string]: (config: any) => PropertyValidatorComponentSync
+}
+
+const simpleFuncWrap = (validator: PropertyValidatorComponentSync) => () => {
+  return validator
+}
+
+const CONFIG_TO_VALIDATE_METHOD: MethodConfigDict = {
+  required: _boolChoice(simpleFuncWrap(isRequired)),
+  isInteger: _boolChoice(simpleFuncWrap(isInteger)),
+  isNumber: _boolChoice(simpleFuncWrap(isNumber)),
+  isString: _boolChoice(simpleFuncWrap(isString)),
+  isArray: _boolChoice(simpleFuncWrap(isArray)),
+  isBoolean: _boolChoice(simpleFuncWrap(isBoolean)),
+  choices: _boolChoice(choices),
+}
+
+const createPropertyValidator = (
+  valueGetter: ValueGetter,
+  config: PropertyConfig
+): PropertyValidator => {
+  const _propertyValidator: PropertyValidator = async (
+    instance,
+    instanceData: FunctionalModel
+  ) => {
+    if (!config) {
+      config = {}
+    }
+    const validators: readonly PropertyValidatorComponent[] = [
+      ...Object.entries(config).map(([key, value]) => {
+        const method = CONFIG_TO_VALIDATE_METHOD[key]
+        if (method) {
+          return method(value)
+        }
+        return emptyValidator
+      }),
+      ...(config.validators ? config.validators : []),
+    ].filter(x => x)
+    const value = await valueGetter()
+    const isRequiredValue = config.required
+      ? true
+      : validators.includes(isRequired)
+    if (!value && !isRequiredValue) {
+      return []
+    }
+    const validator = aggregateValidator(value, validators)
+    const errors = await validator(instance, instanceData)
+    return [...new Set(flatMap(errors))]
+  }
+  return _propertyValidator
+}
+
+const createModelValidator = (
+  validators: PropertyValidators,
+  modelValidators?: readonly ModelComponentValidator[]
+) => {
+  const _modelValidator = async (
+    instance: ModelInstance<any>,
+    options: object
+  ): Promise<ModelErrors> => {
+    return Promise.resolve().then(async () => {
+      if (!instance) {
+        throw new Error(`Instance cannot be empty`)
+      }
+      const keysAndFunctions = Object.entries(validators)
+      const instanceData = await instance.toObj()
+      const propertyValidationErrors = await Promise.all(
+        keysAndFunctions.map(async ([key, validator]) => {
+          return [key, await validator(instance, instanceData)]
+        })
+      )
+      const modelValidationErrors = (
+        await Promise.all(
+          modelValidators
+            ? modelValidators.map(validator =>
+                validator(instance, instanceData, options)
+              )
+            : []
+        )
+      ).filter(x => x)
+      const propertyErrors = propertyValidationErrors
+        .filter(([, errors]) => Boolean(errors) && errors.length > 0)
+        .reduce((acc, [key, errors]) => {
+          return merge(acc, { [String(key)]: errors })
+        }, {})
+      return modelValidationErrors.length > 0
+        ? merge(propertyErrors, { overall: modelValidationErrors })
+        : propertyErrors
+    })
+  }
+  return _modelValidator
+}
+
+export {
+  isNumber,
+  isBoolean,
+  isString,
+  isInteger,
+  isType,
+  isDate,
+  isArray,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  emptyValidator,
+  createPropertyValidator,
+  createModelValidator,
+  arrayType,
+  referenceTypeMatch,
+  TYPE_PRIMITIVES,
+}

package/{features/stepDefinitions/steps.js → stepDefinitions/oldSteps.ts}

@@ -1,72 +1,90 @@
-const assert = require('chai').assert
-const flatMap = require('lodash/flatMap')
-const { Given, When, Then } = require('@cucumber/cucumber')
-const {
-  Model,
+import { assert } from 'chai'
+import flatMap from 'lodash/flatMap'
+import { Given, When, Then } from '@cucumber/cucumber'
+import {
+  BaseModel,
   UniqueId,
   TextProperty,
-  Function,
   Property,
+  WrapperModelMethod,
+  WrapperInstanceMethod,
   ArrayProperty,
   validation,
-} = require('../../index')
+} from '../src'
+import { ModelInstanceMethod, ModelMethod } from '../src/interfaces'
 
-const instanceToString = Function(modelInstance => {
+const instanceToString = WrapperInstanceMethod(modelInstance => {
   return `${modelInstance.getModel().getName()}-Instance`
 })
 
-const instanceToJson = Function(async modelInstance => {
-  return JSON.stringify(await modelInstance.functions.toObj())
+const instanceToJson = WrapperInstanceMethod(async modelInstance => {
+  return JSON.stringify(await modelInstance.toObj())
 })
 
-const modelToString = Function(model => {
-  return `${model.getName()}-[${Object.keys(model.getProperties()).join(',')}]`
+const modelToString = WrapperModelMethod(model => {
+  return `${model.getName()}-[${Object.keys(
+    model.getModelDefinition().properties
+  ).join(',')}]`
 })
 
-const modelWrapper = Function(model => {
+const modelWrapper = WrapperModelMethod(model => {
   return model
 })
 
 const MODEL_DEFINITIONS = {
-  FunctionModel1: Model(
-    'FunctionModel1',
-    {
+  FunctionModel1: BaseModel<{
+    name: string
+    modelWrapper: ModelMethod
+    toString: ModelInstanceMethod
+    toJson: ModelInstanceMethod
+  }>('FunctionModel1', {
+    properties: {
       id: UniqueId({ required: true }),
       name: TextProperty({ required: true }),
     },
+    modelMethods: {
+      modelWrapper,
+    },
+    instanceMethods: {
+      toString: instanceToString,
+      toJson: instanceToJson,
+    },
+  }),
+  TestModel1: BaseModel<{ name: string; type: string; flag: number }>(
+    'TestModel1',
     {
-      modelFunctions: {
-        modelWrapper,
-        toString: modelToString,
-      },
-      instanceFunctions: {
-        toString: instanceToString,
-        toJson: instanceToJson,
+      properties: {
+        name: Property('Text', { required: true }),
+        type: Property('Type', { required: true, isString: true }),
+        flag: Property('Flag', { required: true, isNumber: true }),
       },
     }
   ),
-  TestModel1: Model('TestModel1', {
-    name: Property({ required: true }),
-    type: Property({ required: true, isString: true }),
-    flag: Property({ required: true, isNumber: true }),
-  }),
-  ArrayModel1: Model('ArrayModel1', {
-    ArrayProperty: Property({
-      isArray: true,
-      validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],
-    }),
+  ArrayModel1: BaseModel<{ ArrayProperty: readonly number[] }>('ArrayModel1', {
+    properties: {
+      ArrayProperty: Property('Array', {
+        isArray: true,
+        validators: [validation.arrayType(validation.TYPE_PRIMITIVES.integer)],
+      }),
+    },
   }),
-  ArrayModel2: Model('ArrayModel2', {
-    ArrayProperty: Property({ isArray: true }),
+  ArrayModel2: BaseModel('ArrayModel2', {
+    properties: {
+      ArrayProperty: Property('Array', { isArray: true }),
+    },
   }),
-  ArrayModel3: Model('ArrayModel3', {
-    ArrayProperty: ArrayProperty({}),
+  ArrayModel3: BaseModel('ArrayModel3', {
+    properties: {
+      ArrayProperty: ArrayProperty({}),
+    },
   }),
-  ArrayModel4: Model('ArrayModel4', {
-    ArrayProperty: ArrayProperty({
-      choices: [4, 5, 6],
-      validators: [validation.arrayType(validation.TYPE_PRIMATIVES.integer)],
-    }),
+  ArrayModel4: BaseModel('ArrayModel4', {
+    properties: {
+      ArrayProperty: ArrayProperty({
+        choices: [4, 5, 6],
+        validators: [validation.arrayType(validation.TYPE_PRIMITIVES.integer)],
+      }),
+    },
   }),
 }
 
@@ -106,15 +124,17 @@ const MODEL_INPUT_VALUES = {
 }
 
 const EXPECTED_FIELDS = {
-  TestModel1b: ['getName', 'getType', 'getFlag', 'meta', 'functions'],
+  TestModel1b: ['name', 'type', 'flag'],
 }
 
 Given(
   'the {word} has been created, with {word} inputs provided',
   function (modelDefinition, modelInputValues) {
+    // @ts-ignore
     const def = MODEL_DEFINITIONS[modelDefinition]
     this.model = def
 
+    // @ts-ignore
     const input = MODEL_INPUT_VALUES[modelInputValues]
     if (!def) {
       throw new Error(`${modelDefinition} did not result in a definition`)
@@ -127,7 +147,8 @@ Given(
 )
 
 When('functions.validate is called', function () {
-  return this.instance.functions.validate().then(x => {
+  // @ts-ignore
+  return this.instance.validate().then(x => {
     this.errors = x
   })
 })
@@ -141,6 +162,7 @@ Then('an array of {int} errors is shown', function (errorCount) {
 })
 
 Given('{word} model is used', function (modelDefinition) {
+  // @ts-ignore
   const def = MODEL_DEFINITIONS[modelDefinition]
   if (!def) {
     throw new Error(`${modelDefinition} did not result in a definition`)
@@ -150,6 +172,7 @@ Given('{word} model is used', function (modelDefinition) {
 })
 
 When('{word} data is inserted', function (modelInputValues) {
+  // @ts-ignore
   const input = MODEL_INPUT_VALUES[modelInputValues]
   if (!input) {
     throw new Error(`${modelInputValues} did not result in an input`)
@@ -158,36 +181,36 @@ When('{word} data is inserted', function (modelInputValues) {
 })
 
 Then('{word} expected property is found', function (properties) {
+  // @ts-ignore
   const propertyArray = EXPECTED_FIELDS[properties]
   if (!propertyArray) {
     throw new Error(`${properties} did not result in properties`)
   }
+  // @ts-ignore
   propertyArray.forEach(key => {
-    if (!(key in this.instance)) {
+    if (!(key in this.instance.get)) {
       throw new Error(`Did not find ${key} in model`)
     }
   })
 })
 
 Then('the {word} property is called on the model', function (property) {
-  return this.instance[property]().then(result => {
-    this.results = result
-  })
+  this.results = this.instance.get[property]()
 })
 
-Then('the array values match', function (table) {
+Then('the array values match', async function (table) {
   const expected = JSON.parse(table.rowsHash().array)
-  assert.deepEqual(this.results, expected)
+  assert.deepEqual(await this.results, expected)
 })
 
 Then('{word} property is found', function (propertyKey) {
-  assert.isFunction(this.instance[propertyKey])
+  assert.isFunction(this.instance.get[propertyKey])
 })
 
 Then('{word} instance function is found', function (instanceFunctionKey) {
-  assert.isFunction(this.instance.functions[instanceFunctionKey])
+  assert.isFunction(this.instance.methods[instanceFunctionKey])
 })
 
 Then('{word} model function is found', function (modelFunctionKey) {
-  assert.isFunction(this.model[modelFunctionKey])
+  assert.isFunction(this.model.methods[modelFunctionKey])
 })