functional-models 1.1.3 → 1.1.4

package/cucumber.js

@@ -1,10 +0,0 @@
-const common = [
-  'features/**/*.feature',
-  '--require-module ts-node/register',
-  '--require ./stepDefinitions/*.ts',
-  '--format progress-bar',
-].join(' ')
-
-module.exports = {
-  default: common,
-}

package/features/arrayFields.feature

@@ -1,52 +0,0 @@
-Feature: Array Property
-
-  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 ArrayProperty 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 property but has a non-array inserted into it fails validation
-    Given ArrayModel1 model is used
-    When ArrayModelData2 data is inserted
-    Then the ArrayProperty 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 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 ArrayProperty 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 property that has mixed values it should not fail validation.
-    Given ArrayModel2 model is used
-    When ArrayModelData4 data is inserted
-    Then the ArrayProperty 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 arrayProperty property that has mixed values it should not fail validation.
-    Given ArrayModel3 model is used
-    When ArrayModelData4 data is inserted
-    Then the ArrayProperty 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 arrayProperty with the choice validator should pass validation with no errors.
-    Given ArrayModel4 model is used
-    When ArrayModelData5 data is inserted
-    Then the ArrayProperty 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 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 ArrayProperty property is called on the model
-    Then functions.validate is called
-    Then an array of 1 errors is shown

package/features/basic-ts.feature

@@ -1,13 +0,0 @@
-Feature: Basic Typescript
-
-  Scenario: A model with properties, instance methods, and model methods works as expected.
-    Given model TE_FULL_TEST is used
-    When a model instanced is created is called on model with TE_FULL_TEST_1
-    And toObj is called on the model instance
-    And instance method myMethod is called
-    And model method myModelMethod is called
-    And validate is called on model instance
-    Then the results match TE_FULL_TEST_1 obj data
-    And the result of instance method is InstanceMethod
-    And the result of model method is ModelMethod
-    And the model instance validated successfully

package/features/functions.feature

@@ -1,10 +0,0 @@
-Feature: Functions
-
-  Scenario: A model with 2 properties (name, id), 2 model functions (modelWrapper, toString), and 2 instance functions (toString, toJson)
-    Given FunctionModel1 model is used
-    When FunctionModelData1 data is inserted
-    Then name property is found
-    And id property is found
-    And toString instance function is found
-    And toJson instance function is found
-    And modelWrapper model function is found

package/features/model.feature

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

package/features/validation.feature

@@ -1,12 +0,0 @@
-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/index.js

@@ -1 +0,0 @@
-module.exports = require('./src/index')

package/src/constants.ts

@@ -1,15 +0,0 @@
-enum PROPERTY_TYPES {
-  UniqueId = 'UniqueId',
-  DateProperty = 'DateProperty',
-  ArrayProperty = 'ArrayProperty',
-  ReferenceProperty = 'ReferenceProperty',
-  IntegerProperty = 'IntegerProperty',
-  TextProperty = 'TextProperty',
-  ConstantValueProperty = 'ConstantValueProperty',
-  NumberProperty = 'NumberProperty',
-  ObjectProperty = 'ObjectProperty',
-  EmailProperty = 'EmailProperty',
-  BooleanProperty = 'BooleanProperty',
-}
-
-export { PROPERTY_TYPES }

package/src/errors.ts

@@ -1,18 +0,0 @@
-type KeysToErrors = { [s: string]: string[] }
-
-/* eslint-disable functional/no-this-expression */
-/* eslint-disable functional/no-class */
-class ValidationError extends Error {
-  public modelName: String
-  public keysToErrors: KeysToErrors
-  constructor(modelName: String, keysToErrors: 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 */
-
-export { ValidationError }

package/src/index.ts

@@ -1,12 +0,0 @@
-import * as constants from './constants'
-import * as errors from './errors'
-import * as validation from './validation'
-import * as serialization from './serialization'
-import * as utils from './utils'
-import * as interfaces from './interfaces'
-
-export * from './models'
-export * from './properties'
-export * from './methods'
-
-export { constants, errors, validation, serialization, utils, interfaces }

package/src/interfaces.ts

@@ -1,323 +0,0 @@
-/* eslint-disable no-unused-vars */
-
-type MaybeFunction<T> = T | (() => T)
-type MaybePromise<T> = T | Promise<T>
-type Nullable<T> = T | null
-type Maybe<T> = T | undefined | null
-type Arrayable<T> = T | readonly T[]
-type MaybeLazy<T> = Maybe<Promise<T>>
-type MaybeEmpty<T> = T | null | undefined
-type JsonAble =
-  | number
-  | string
-  | boolean
-  | null
-  | Arrayable<{ readonly [s: string]: JsonAble }>
-type VeryPrimitivesTypes = null | string | number | boolean
-type toObj = () => Promise<JsonAble>
-
-type ValueIsOfType<T, V> = {
-  readonly [P in keyof T as T[P] extends V ? P : never]: T[P]
-}
-
-type ValueIsNotOfType<T, V> = {
-  readonly [P in keyof T as T[P] extends V ? never : P]: T[P]
-}
-
-type InstanceMethodGetters<T> = {
-  readonly [P in keyof T as T[P] extends ModelInstanceMethod
-    ? P
-    : never]: ModelInstanceMethodClient
-}
-
-type ModelMethodGetters<T> = {
-  readonly [P in keyof T as T[P] extends ModelMethod
-    ? P
-    : never]: ModelMethodClient
-}
-
-type ModelMethodTypes<T extends FunctionalModel> =
-  | ModelMethod
-  | ModelInstanceMethod
-  | ModelMethodTyped<T>
-  | ModelInstanceMethodTyped<T>
-
-type PropertyGetters<T extends FunctionalModel> = {
-  readonly // NOTE: This is NOT ModelMethodTypes, its getting everything but.
-  [Property in keyof T as T[Property] extends ModelMethodTypes<T>
-    ? never
-    : Property]: () => T[Property] | Promise<T[Property]>
-}
-
-type FunctionalModel =
-  | {
-      readonly [s: string]:
-        | Arrayable<number>
-        | Arrayable<string>
-        | Arrayable<boolean>
-        | Arrayable<null>
-        | Arrayable<FunctionalModel>
-        | Arrayable<Date>
-        | Arrayable<undefined>
-        | ReferenceValueType<any>
-        | ModelInstanceMethod
-        | ModelMethod
-    }
-  | JsonAble
-
-type FunctionalType =
-  | JsonAble
-  | (() => FunctionalType)
-  | Arrayable<undefined>
-  | Arrayable<Date>
-  | Arrayable<FunctionalModel>
-  | Arrayable<{ readonly [s: string]: JsonAble }>
-
-type ModelInstanceInputData<T extends FunctionalModel> = ValueIsNotOfType<
-  T,
-  ModelMethodTypes<T>
->
-
-type PropertyValidatorComponentTypeAdvanced<
-  TValue,
-  TModel extends FunctionalModel
-> = (
-  value: TValue,
-  instance: ModelInstance<TModel>,
-  instanceData: FunctionalModel
-) => string | undefined
-
-type PropertyValidatorComponentType<TValue> = (
-  value: TValue,
-  instance: ModelInstance<any>,
-  instanceData: FunctionalModel
-) => string | undefined
-
-type PropertyValidatorComponentSync = PropertyValidatorComponentType<any>
-
-type PropertyValidatorComponentAsync = (
-  value: Arrayable<FunctionalModel>,
-  instance: ModelInstance<any>,
-  instanceData: FunctionalModel
-) => Promise<string | undefined>
-
-type PropertyValidatorComponent =
-  | PropertyValidatorComponentSync
-  | PropertyValidatorComponentAsync
-
-type PropertyValidator = (
-  instance: ModelInstance<any>,
-  instanceData: FunctionalModel
-) => Promise<ValidationErrors>
-
-type ValidationError = string | undefined
-type ValidationErrors = readonly ValidationError[]
-type ModelError = string
-type ModelErrors = {
-  readonly [s: string]: readonly ModelError[]
-}
-
-type ModelComponentValidator = (
-  instance: ModelInstance<any>,
-  instanceData: FunctionalModel,
-  options?: object
-) => Promise<ValidationErrors>
-
-type ValueGetter = () =>
-  | MaybePromise<Arrayable<FunctionalType>>
-  | MaybePromise<ModelInstance<any>>
-
-type PropertyInstance<T extends Arrayable<FunctionalType>> = {
-  readonly getConfig: () => object
-  readonly getChoices: () => readonly VeryPrimitivesTypes[]
-  readonly getDefaultValue: () => T
-  readonly getConstantValue: () => T
-  readonly getPropertyType: () => string
-  readonly createGetter: (value: T) => ValueGetter
-  readonly getValidator: (valueGetter: ValueGetter) => PropertyValidator
-}
-
-type PropertiesList<T> = {
-  readonly [P in keyof T as T[P] extends Arrayable<FunctionalType>
-    ? P
-    : never]: PropertyInstance<any>
-}
-
-interface ReferencePropertyInstance<T extends FunctionalModel>
-  extends PropertyInstance<ModelInstance<T> | T | MaybeEmpty<PrimaryKeyType>> {
-  readonly getReferencedId: (
-    instanceValues: ReferenceValueType<T>
-  ) => MaybeEmpty<PrimaryKeyType>
-  readonly getReferencedModel: () => Model<T>
-}
-
-type ReferenceValueType<T extends FunctionalModel> =
-  | ModelInstance<T>
-  | ModelInstanceInputData<T>
-  | string
-  | number
-  | null
-  | undefined
-
-type DefaultPropertyValidators = {
-  readonly required?: boolean
-  readonly isInteger?: boolean
-  readonly isNumber?: boolean
-  readonly isString?: boolean
-  readonly isArray?: boolean
-  readonly isBoolean?: boolean
-}
-
-type PropertyConfigContents = {
-  readonly type?: string
-  readonly defaultValue?: Arrayable<FunctionalType>
-  readonly value?: Arrayable<FunctionalType>
-  readonly choices?: readonly VeryPrimitivesTypes[]
-  readonly lazyLoadMethod?: (
-    value: Arrayable<FunctionalType>
-  ) => MaybeLazy<Arrayable<FunctionalType>>
-  readonly valueSelector?: (
-    instanceValue: MaybePromise<Arrayable<FunctionalType>>
-  ) => Arrayable<FunctionalType>
-  readonly validators?: readonly PropertyValidatorComponent[]
-  readonly maxLength?: number
-  readonly minLength?: number
-  readonly maxValue?: number
-  readonly minValue?: number
-  readonly autoNow?: boolean
-  readonly fetcher?: (
-    model: Model<any>,
-    primaryKey: PrimaryKeyType
-  ) => Promise<any>
-}
-
-type PropertyConfig =
-  | (PropertyConfigContents & DefaultPropertyValidators)
-  | undefined
-
-type PrimaryKeyPropertyInstanceType =
-  | PropertyInstance<string>
-  | PropertyInstance<number>
-type PrimaryKeyType = string | number
-
-type ModelMethods<T extends FunctionalModel> = ValueIsOfType<
-  T,
-  ModelMethod | ModelMethodTyped<T>
->
-type InstanceMethods<T extends FunctionalModel> = ValueIsOfType<
-  T,
-  ModelInstanceMethod | ModelInstanceMethodTyped<T>
->
-type ModelDefinition<T extends FunctionalModel> = {
-  readonly getPrimaryKeyName?: () => string
-  readonly properties: PropertiesList<T> & {
-    readonly id?: PrimaryKeyPropertyInstanceType
-  }
-  readonly instanceMethods?: InstanceMethods<T>
-  readonly modelMethods?: ModelMethods<T>
-  readonly modelValidators?: readonly ModelComponentValidator[]
-}
-
-type Model<T extends FunctionalModel> = {
-  readonly getName: () => string
-  readonly getPrimaryKeyName: () => string
-  readonly getModelDefinition: () => ModelDefinition<T>
-  readonly getPrimaryKey: (t: ModelInstanceInputData<T>) => PrimaryKeyType
-  readonly create: (
-    data: ModelInstanceInputData<T> & { readonly id?: PrimaryKeyType }
-  ) => ModelInstance<T>
-  readonly methods: ModelMethodGetters<T>
-}
-
-type ReferenceFunctions = {
-  readonly [s: string]: () => ReferenceValueType<any>
-}
-
-type PropertyValidators = {
-  readonly [s: string]: PropertyValidator
-}
-
-type ModelInstance<T extends FunctionalModel> = {
-  readonly get: PropertyGetters<T> & {
-    readonly id: () => MaybePromise<PrimaryKeyType>
-  }
-  readonly methods: InstanceMethodGetters<T>
-  readonly references: ReferenceFunctions
-  readonly toObj: toObj
-  readonly getPrimaryKeyName: () => string
-  readonly getPrimaryKey: () => PrimaryKeyType
-  readonly validators: PropertyValidators
-  readonly validate: (options?: {}) => Promise<ModelErrors>
-  readonly getModel: () => Model<T>
-}
-
-type ModelMethodTyped<T extends FunctionalModel> = (
-  model: Model<T>,
-  args?: readonly any[]
-) => any
-type ModelMethod = ModelMethodTyped<any>
-type ModelMethodClient = (...args: readonly any[]) => any
-type ModelInstanceMethodTyped<T extends FunctionalModel> = (
-  instance: ModelInstance<T>,
-  args?: readonly any[]
-) => any
-type ModelInstanceMethod = ModelInstanceMethodTyped<any>
-type ModelInstanceMethodClient = (...args: readonly any[]) => any
-
-type ModelOptions = {
-  readonly instanceCreatedCallback: Nullable<
-    Arrayable<(instance: ModelInstance<any>) => void>
-  >
-}
-
-type OptionalModelOptions =
-  | {
-      readonly instanceCreatedCallback?: Nullable<
-        Arrayable<(instance: ModelInstance<any>) => void>
-      >
-    }
-  | undefined
-
-export {
-  MaybeFunction,
-  Maybe,
-  MaybePromise,
-  Nullable,
-  Arrayable,
-  MaybeLazy,
-  JsonAble,
-  toObj,
-  ModelInstance,
-  Model,
-  PropertyValidatorComponent,
-  PropertyValidatorComponentSync,
-  PropertyValidatorComponentAsync,
-  PropertyValidatorComponentType,
-  PropertyValidator,
-  ModelComponentValidator,
-  PropertyInstance,
-  PropertyConfig,
-  FunctionalType,
-  ValueGetter,
-  ReferenceValueType,
-  ModelDefinition,
-  ModelOptions,
-  ModelMethod,
-  OptionalModelOptions,
-  ReferencePropertyInstance,
-  PropertyGetters,
-  PropertyValidators,
-  PropertyValidatorComponentTypeAdvanced,
-  ModelInstanceMethod,
-  ModelInstanceMethodTyped,
-  FunctionalModel,
-  ModelInstanceInputData,
-  ModelMethodTyped,
-  ModelMethodGetters,
-  InstanceMethodGetters,
-  ReferenceFunctions,
-  ModelErrors,
-  MaybeEmpty,
-  PrimaryKeyType,
-}
-/* eslint-enable no-unused-vars */

package/src/lazy.ts

@@ -1,24 +0,0 @@
-import AsyncLock from 'async-lock'
-import { createUuid } from './utils'
-
-const lazyValue = (method: Function) => {
-  const key = createUuid()
-  const lock = new AsyncLock()
-  /* eslint-disable functional/no-let */
-  let value: any = undefined
-  let called = false
-  return async (...args: readonly any[]) => {
-    return lock.acquire(key, async () => {
-      if (!called) {
-        called = true
-        value = await method(...args)
-        // eslint-disable-next-line require-atomic-updates
-      }
-
-      return value
-    })
-  }
-  /* eslint-enable functional/no-let */
-}
-
-export { lazyValue }

package/src/methods.ts

@@ -1,30 +0,0 @@
-import {
-  ModelInstanceMethodTyped,
-  ModelInstance,
-  FunctionalModel,
-  Model,
-  ModelMethodTyped,
-} from './interfaces'
-
-const WrapperInstanceMethod = <T extends FunctionalModel>(
-  method: (instance: ModelInstance<T>, args?: readonly any[]) => any
-) => {
-  const r: ModelInstanceMethodTyped<T> = (
-    instance: ModelInstance<T>,
-    ...args: readonly any[]
-  ) => {
-    return method(instance, ...args)
-  }
-  return r
-}
-
-const WrapperModelMethod = <T extends FunctionalModel>(
-  method: (model: Model<T>, args?: readonly any[]) => any
-) => {
-  const r: ModelMethodTyped<T> = (model: Model<T>, ...args: readonly any[]) => {
-    return method(model, ...args)
-  }
-  return r
-}
-
-export { WrapperInstanceMethod, WrapperModelMethod }