functional-models 1.1.3 → 1.1.4

package/src/validation.ts

@@ -1,390 +0,0 @@
-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/stepDefinitions/oldSteps.ts

@@ -1,216 +0,0 @@
-import { assert } from 'chai'
-import flatMap from 'lodash/flatMap'
-import { Given, When, Then } from '@cucumber/cucumber'
-import {
-  BaseModel,
-  UniqueId,
-  TextProperty,
-  Property,
-  WrapperModelMethod,
-  WrapperInstanceMethod,
-  ArrayProperty,
-  validation,
-} from '../src'
-import { ModelInstanceMethod, ModelMethod } from '../src/interfaces'
-
-const instanceToString = WrapperInstanceMethod(modelInstance => {
-  return `${modelInstance.getModel().getName()}-Instance`
-})
-
-const instanceToJson = WrapperInstanceMethod(async modelInstance => {
-  return JSON.stringify(await modelInstance.toObj())
-})
-
-const modelToString = WrapperModelMethod(model => {
-  return `${model.getName()}-[${Object.keys(
-    model.getModelDefinition().properties
-  ).join(',')}]`
-})
-
-const modelWrapper = WrapperModelMethod(model => {
-  return model
-})
-
-const MODEL_DEFINITIONS = {
-  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',
-    {
-      properties: {
-        name: Property('Text', { required: true }),
-        type: Property('Type', { required: true, isString: true }),
-        flag: Property('Flag', { required: true, isNumber: true }),
-      },
-    }
-  ),
-  ArrayModel1: BaseModel<{ ArrayProperty: readonly number[] }>('ArrayModel1', {
-    properties: {
-      ArrayProperty: Property('Array', {
-        isArray: true,
-        validators: [validation.arrayType(validation.TYPE_PRIMITIVES.integer)],
-      }),
-    },
-  }),
-  ArrayModel2: BaseModel('ArrayModel2', {
-    properties: {
-      ArrayProperty: Property('Array', { isArray: true }),
-    },
-  }),
-  ArrayModel3: BaseModel('ArrayModel3', {
-    properties: {
-      ArrayProperty: ArrayProperty({}),
-    },
-  }),
-  ArrayModel4: BaseModel('ArrayModel4', {
-    properties: {
-      ArrayProperty: ArrayProperty({
-        choices: [4, 5, 6],
-        validators: [validation.arrayType(validation.TYPE_PRIMITIVES.integer)],
-      }),
-    },
-  }),
-}
-
-const MODEL_INPUT_VALUES = {
-  FunctionModelData1: {
-    id: 'my-id',
-    name: 'function-model-name',
-  },
-  TestModel1a: {
-    name: 'my-name',
-    type: 1,
-    flag: '1',
-  },
-  TestModel1b: {
-    name: 'my-name',
-    type: 'a-type',
-    flag: 1,
-  },
-  ArrayModelData1: {
-    ArrayProperty: [1, 2, 3, 4, 5],
-  },
-  ArrayModelData2: {
-    ArrayProperty: 'a-string',
-  },
-  ArrayModelData3: {
-    ArrayProperty: ['a-string', 'a-string2'],
-  },
-  ArrayModelData4: {
-    ArrayProperty: ['a-string', 1, {}, true],
-  },
-  ArrayModelData5: {
-    ArrayProperty: [4, 5, 5, 5, 6],
-  },
-  ArrayModelData6: {
-    ArrayProperty: [4, 5, 5, 5, 6, 1],
-  },
-}
-
-const EXPECTED_FIELDS = {
-  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`)
-    }
-    if (!input) {
-      throw new Error(`${modelInputValues} did not result in an input`)
-    }
-    this.instance = def.create(input)
-  }
-)
-
-When('functions.validate is called', function () {
-  // @ts-ignore
-  return this.instance.validate().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} model is used', function (modelDefinition) {
-  // @ts-ignore
-  const def = MODEL_DEFINITIONS[modelDefinition]
-  if (!def) {
-    throw new Error(`${modelDefinition} did not result in a definition`)
-  }
-  this.modelDefinition = def
-  this.model = def
-})
-
-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`)
-  }
-  this.instance = this.modelDefinition.create(input)
-})
-
-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.get)) {
-      throw new Error(`Did not find ${key} in model`)
-    }
-  })
-})
-
-Then('the {word} property is called on the model', function (property) {
-  this.results = this.instance.get[property]()
-})
-
-Then('the array values match', async function (table) {
-  const expected = JSON.parse(table.rowsHash().array)
-  assert.deepEqual(await this.results, expected)
-})
-
-Then('{word} property is found', function (propertyKey) {
-  assert.isFunction(this.instance.get[propertyKey])
-})
-
-Then('{word} instance function is found', function (instanceFunctionKey) {
-  assert.isFunction(this.instance.methods[instanceFunctionKey])
-})
-
-Then('{word} model function is found', function (modelFunctionKey) {
-  assert.isFunction(this.model.methods[modelFunctionKey])
-})

package/stepDefinitions/tssteps.ts

@@ -1,107 +0,0 @@
-import { Given, When, Then } from '@cucumber/cucumber'
-import { assert } from 'chai'
-import { BaseModel } from '../src/models'
-import { WrapperInstanceMethod, WrapperModelMethod } from '../src/methods'
-import {
-  Model,
-  FunctionalModel,
-  ModelInstanceMethodTyped,
-  ModelMethodTyped,
-  ModelInstanceInputData,
-  Nullable,
-} from '../src/interfaces'
-import { ObjectProperty, TextProperty, UniqueId } from '../src/properties'
-
-type MyTSType = {
-  name: string
-  data: FunctionalModel
-  notRequired?: Nullable<string>
-  myMethod: ModelInstanceMethodTyped<MyTSType>
-  myModelMethod: ModelMethodTyped<MyTSType>
-}
-
-const TE_FULL_TEST = () => {
-  const m = BaseModel<MyTSType>('TSFullTests', {
-    properties: {
-      id: UniqueId({ value: 'my-unique-id' }),
-      name: TextProperty({ required: true }),
-      data: ObjectProperty({}),
-      notRequired: TextProperty({}),
-    },
-    instanceMethods: {
-      myMethod: WrapperInstanceMethod<MyTSType>((instance, args) => {
-        return 'InstanceMethod'
-      }),
-    },
-    modelMethods: {
-      myModelMethod: WrapperModelMethod<MyTSType>((model, args) => {
-        return 'ModelMethod'
-      }),
-    },
-  })
-  return m
-}
-
-const TE_FULL_TEST_1 = () => {
-  return {
-    id: 'my-unique-id',
-    name: 'My name',
-    data: { my: 'data' },
-    notRequired: null,
-  }
-}
-
-const DATA_SET: { [s: string]: () => ModelInstanceInputData<MyTSType> } = {
-  TE_FULL_TEST_1,
-}
-
-const MODEL_SET: { [s: string]: () => Model<MyTSType> } = {
-  TE_FULL_TEST,
-}
-
-Given('model {word} is used', function (modelName: string) {
-  this.theModel = MODEL_SET[modelName]()
-})
-
-When(
-  'a model instanced is created is called on model with {word}',
-  async function (dataName: string) {
-    this.theModelInstance = this.theModel.create(DATA_SET[dataName]())
-  }
-)
-
-When('toObj is called on the model instance', async function () {
-  this.results = await this.theModelInstance.toObj()
-})
-
-Then('the results match {word} obj data', function (dataName) {
-  const data = DATA_SET[dataName]()
-  assert.deepEqual(data, this.results)
-})
-
-When('instance method {word} is called', async function (methodName) {
-  this.instanceMethodActual = await this.theModelInstance.methods[methodName]()
-})
-
-Then('the result of instance method is {word}', function (expected) {
-  const actual = this.instanceMethodActual
-  assert.equal(actual, expected)
-})
-
-When('model method {word} is called', async function (methodName) {
-  this.modelMethodActual = await this.theModel.methods[methodName]()
-})
-
-Then('the result of model method is {word}', function (expected) {
-  const actual = this.modelMethodActual
-  assert.equal(actual, expected)
-})
-
-When('validate is called on model instance', async function () {
-  this.validationActual = await this.theModelInstance.validate()
-})
-
-Then('the model instance validated successfully', function () {
-  const expected = {}
-  assert.deepEqual(this.validationActual, expected)
-})