functional-models 1.0.25 → 1.1.0

package/.eslintignore

@@ -2,3 +2,4 @@ dist/
 node_modules/
 test/
 features/
+stepDefinitions/

package/.eslintrc

@@ -1,6 +1,6 @@
 {
   "extends": ["eslint:recommended", "prettier"],
-  "plugins": ["import", "functional"],
+  "plugins": ["import", "functional", "@typescript-eslint"],
   "env": {
     "browser": true,
     "node": true,
@@ -8,6 +8,8 @@
     "es6": true
   },
   "rules": {
+    "@typescript-eslint/no-unused-vars": "error",
+
     "no-await-in-loop": ["error"],
     "no-console": ["error", { "allow": ["warn", "error", "info"] }],
     "no-constant-condition": ["error"],
@@ -91,15 +93,7 @@
     "linebreak-style": 0,
     "no-underscore-dangle": 0,
     "no-unused-labels": 0,
-    "no-unused-vars": [
-      "error",
-      {
-        "vars": "all",
-        "argsIgnorePattern": "(_+)|(action)",
-        "args": "after-used",
-        "ignoreRestSiblings": false
-      }
-    ],
+    "no-unused-vars": 0,
     "object-shorthand": 0,
     "prefer-rest-params": 0,
     "semi": ["error", "never"],
@@ -114,13 +108,13 @@
     "functional/no-method-signature": ["error"],
     "functional/prefer-readonly-type": ["error"],
     "functional/no-class": ["error"],
-    "functional/no-mixed-type": ["error"],
+    "functional/no-mixed-type": 0,
     "functional/no-this-expression": ["error"],
-    "functional/prefer-type-literal": ["error"],
+    "functional/prefer-type-literal": 0,
     "functional/no-conditional-statement": 0,
     "functional/no-expression-statement": 0,
     "functional/no-loop-statement": ["error"],
-    "functional/no-return-void": ["error"],
+    "functional/no-return-void": 0,
     "functional/no-promise-reject": 0,
     "functional/no-throw-statement": 0,
     "functional/no-try-statement": ["error"],
@@ -156,7 +150,7 @@
     "import/first": ["error"],
     "import/exports-last": ["error"],
     "import/no-duplicates": ["error"],
-    "import/no-namespace": ["error"],
+    "import/no-namespace": 0,
     "import/extensions": ["error"],
     "import/order": ["error"],
     "import/newline-after-import": ["error"],
@@ -182,5 +176,5 @@
       "jsx": true
     }
   },
-  "parser": "babel-eslint"
+  "parser": "@typescript-eslint/parser"
 }

package/cucumber.js

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

package/features/arrayFields.feature

@@ -3,7 +3,7 @@ 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 getArrayProperty property is called on the model
+    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
@@ -12,41 +12,41 @@ Feature: Array Property
   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 getArrayProperty property is called on the model
+    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 getArrayProperty property is called on the model
+    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 getArrayProperty property is called on the model
+    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 getArrayProperty property is called on the model
+    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 getArrayProperty property is called on the model
+    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 getArrayProperty property is called on the model
+    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

@@ -0,0 +1,13 @@
+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

@@ -3,9 +3,8 @@ 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 getName property is found
-    And getId property is found
+    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
-    And toString model function is found

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "functional-models",
-  "version": "1.0.25",
+  "version": "1.1.0",
   "description": "A library for creating JavaScript function based models.",
-  "main": "index.js",
+  "main": "src/index.js",
   "scripts": {
-    "test": "nyc --all mocha --recursive './test/**/*.test.js'",
-    "feature-tests": "./node_modules/@cucumber/cucumber/bin/cucumber-js",
+    "test": "mocha -r ts-node/register test/**/*.test.ts",
+    "test:coverage": "nyc npm run test",
+    "feature-tests": "./node_modules/.bin/cucumber-js -p default",
     "coverage": "nyc --all --reporter=lcov npm test"
   },
   "repository": {
@@ -27,18 +28,37 @@
   },
   "homepage": "https://github.com/monolithst/functional-models#readme",
   "nyc": {
+    "extends": "@istanbuljs/nyc-config-typescript",
+    "check-coverage": true,
     "all": true,
+    "include": [
+      "src/**/!(*.test.*).[tj]s?(x)"
+    ],
     "exclude": [
-      "coverage/",
-      "features/stepDefinitions/*",
-      "test/*"
-    ]
+      "src/_tests_/**/*.*"
+    ],
+    "reporter": [
+      "html",
+      "lcov",
+      "text",
+      "text-summary"
+    ],
+    "report-dir": "coverage"
   },
   "devDependencies": {
+    "@cucumber/cucumber": "^8.0.0-rc.1",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
+    "@types/async-lock": "^1.1.3",
+    "@types/chai": "^4.2.22",
+    "@types/chai-as-promised": "^7.1.4",
+    "@types/lodash": "^4.14.176",
+    "@types/mocha": "^9.0.0",
+    "@types/proxyquire": "^1.3.28",
+    "@types/sinon": "^10.0.6",
+    "@typescript-eslint/eslint-plugin": "^5.6.0",
     "babel-eslint": "^10.1.0",
     "chai": "^4.3.0",
     "chai-as-promised": "^7.1.1",
-    "cucumber": "^7.0.0-rc.0",
     "eslint": "^7.19.0",
     "eslint-config-prettier": "^7.2.0",
     "eslint-plugin-functional": "^3.2.1",
@@ -46,9 +66,13 @@
     "mocha": "^8.2.1",
     "nyc": "^15.1.0",
     "proxyquire": "^2.1.3",
-    "sinon": "^11.1.2"
+    "sinon": "^11.1.2",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.4.4"
   },
   "dependencies": {
+    "@typescript-eslint/parser": "^5.3.0",
+    "async-lock": "^1.3.0",
     "get-random-values": "^1.2.2",
     "lodash": "^4.17.21"
   }

package/src/constants.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,11 @@
+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'
+
+export * from './models'
+export * from './properties'
+export * from './methods'
+
+export { constants, errors, validation, serialization, utils }

package/src/interfaces.ts

@@ -0,0 +1,323 @@
+/* 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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,30 @@
+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 }