thesimplevalidation 1.1.2 → 2.0.0

package/README.md

@@ -2,208 +2,209 @@
 
 The simple validation service
 
-[![Build Status](https://travis-ci.org/ripenko/thesimplevalidation.svg?branch=master)](https://travis-ci.org/ripenko/thesimplevalidation)
-
 ## Installation
+
 ```
 npm install --save thesimplevalidation
 ```
 
 ## Setup
-There are paar steps to enable validation.
 
-### 1. Create a model
-```typescript
-interface IModel {
-    title: string;
-    description: string;
-}
-```
+### create validation
 
-### 2. Create or use state, or something similar where we store user model values
-```typescript
-this.model: IModel = {
-    title: "",
-    description: ""
-};
-```
+Create a validation using model that is passed to contructor as original model. The original model will be used to identity dirty properties.
 
-### 3. Create validation model, validation errors model
 ```typescript
-import { ValidationModel } from "thesimplevalidation";
-
-this.validation: ValidationModel<IModel> = {
-    title: false,
-    description: true
-};
+import Validation from "thesimplevalidation";
 
-this.validationErrors: ValidationErrorsModel<IModel> = {
-    title: [];
-    description: [];
-};
-
-this.allValidationErrors: string [] = [];
-
-this.isValid: boolean = false;
-```
-
-
-### 4. Creating Validation Scope
-```typescript
-import { ValidationScope } from "thesimplevalidation";
-
-const scope = new ValidationScope<IModel>({
-    getModel: (): IModel => this.model
+const validation = new Validation({
+  title: "",
+  description: "",
 });
-
 ```
 
-### 5. Add validators to model property(ies)
+### Add validators to model property(ies)
+
 There are some built-in validators like `RequiredValidator`, `MinValidator`, `MaxValidator`, `SimpleValidator`, `BooleanValidator`. You can create own by yourself. It is easy.
 So. To add validators we use validation scope method `useValidators`.
+
 ```typescript
 import { RequiredValidator } from "thesimplevalidation";
 
-this.scope.useValidators("title", new RequiredValidator());
-
+this.validation.useValidators("title", new RequiredValidator());
 ```
 
 ### 6. Do validation
+
 ```typescript
-const result: IValidationResult<IModel> = await this.scope.isValid();
-console.log(result.isValid, result); 
+const result = await this.scope.isValid({
+  title: "",
+  description: "",
+});
+
+console.log(result.isValid, result);
 // -> false, { isValid: false, properties: { title: { isValid: false, errors: [] }, description: { isValid: true, errors: [] } }, errors: [] }
 ```
 
 ## Usage
 
-### ValidationScope
-This class is main point to define validation. Possible to define more than one scope in the form. As you wish.
+### Validation
+
+This class is main point to define validation. Possible to define more than one instance in the form. As you wish.
+
 ```typescript
-const scope = new ValidationScope<IModel>({
-    getModel: (): IModel => this.model
-    onValidationChanged: async (result: IValidationResult<TModel>): Promise<void> => {
-        const properties: Array<keyof TModel> = keys(result.properties) as Array<keyof TModel>;
-        const validation: ValidationModel<TModel> = {} as ValidationModel<TModel>;
-        const validationErrors: ValidationErrorsModel<TModel> = {} as ValidationErrorsModel<TModel>;
-
-        for (const property of properties) {
-            if (!result.properties.hasOwnProperty(property)) continue;
-            
-            validation[property] = result.properties[property].isValid;
-            validationErrors[property] = result.properties[property].errors;
-        }
-
-        this.isValid = result.isValid;
-        this.validation = validation;
-        this.validationErrors = validationErrors;
-        this.allValidationErrors = result.errors;
-    }
-});
+const validation = new Validation<Model>({
+  firstName: "",
+  lastName: "",
+})
+  .useValidators("firstName", new RequiredValidator())
+  .useValidators("lastName", new RequiredValidator());
 ```
-`getModel` is invoked on validation by method `isValid`.
-`onValidationChanged` Optional. To handle validation result. It is invoked before `isValid` method is completed.
+
+The value that is passed to constructor is used as initial model or original model.
 
 ### `isValid`
+
 Validates the whole model.
+
 ```typescript
-const result: IValidationResult<IModel> = await this.scope.isValid();
+const model = {
+  firstName: "Alexey",
+  lastName: "",
+};
+
+const result: ValidationResult<Model> = await this.validation.isValid(model);
 console.log(result.isValid); // -> false
 ```
 
 #### `isPropertyValid`
+
 Validates only a specific property.
+
 ```typescript
-const propertyResult: IValidationPropertyResult = await this.scope.isPropertyValid("description");
+const propertyResult: ValidationPropertyResult =
+  await this.validation.isPropertyValid(model, "firstName");
 console.log(propertyResult.isValid); // -> false
 ```
 
 #### `useValidators`
+
 Use this method to set validators for property.
+
 ```typescript
-this.scope.useValidators(
-    "title", // property
-    new RequiredValidator(), 
-    new MaxValidator({ maxValue: () => 10 }),
-    // add more validators if you need
+this.validation.useValidators(
+  "title", // property
+  new RequiredValidator(),
+  new MaxValidator({ maxValue: () => 10 })
+  // add more validators if you need
 );
 ```
 
 #### `useOriginal`
-You have built-in ability to check if the property has been changed or not. `isDirty`. 
+
+You have built-in ability to check if the property has been changed or not. `isDirty`.
 To do it scope save a deep cloned copy of the model on init. When we invoke `isDirty`, then `isDirty` method compares value to saved copy.
 `useOriginal` resets saved cloned copy of model.
+
 ```typescript
-this.scope.useOriginal(newModel);
+this.validation.useOriginal({
+  firstName: "Alexey",
+  lastName: "Ripenko",
+});
 ```
 
 #### `isPropertyDirty`
+
 The method of the validation scope allows to check if property has been changed (dirty).
+
 ```typescript
-this.model.title = "New Title";
-let isTitleDirty: boolean = this.scope.isPropertyDirty("title");
-console.log(isTitleDirty); // -> true
+this.model.firstName = "Mike";
+let isFirstNameDirty: boolean = this.validation.isPropertyDirty(
+  model,
+  "firstName"
+);
+console.log(isFirstNameDirty); // -> true
 
-this.scope.useOriginal(this.model);
-isTitleDirty = this.scope.isPropertyDirty("title");
-console.log(isTitleDirty); // -> false
+this.validation.useOriginal(this.model);
+isFirstNameDirty = this.validation.isPropertyDirty(model, "firstName");
+console.log(isFirstNameDirty); // -> false
 ```
 
 This method has optional `key` parameter. It uses to use nested value if property is object with nested object-properties. Example `someProperty.someNestedProperty.key`, `arrayProperty.key`.
 
-
 #### `getOriginalProperty`
+
 Gets property from saved cloned model.
+
 ```typescript
-const originalTitle = this.scope.getOriginalProperty("title");
+const originalFirstName = this.validation.getOriginalProperty("firstName");
 ```
 
 #### `isDirty`
+
 Checks if model or model properties have been changed (dirty).
 
 Checks the whole model
+
 ```typescript
-this.scope.isDirty();
+this.validation.isDirty(model);
 ```
-or checks only `title` property
+
+or checks only `firstName` property
+
 ```typescript
-this.scope.isDirty("title");
+this.validation.isDirty(model, "firstName");
 ```
+
 or checks multiple properties
+
 ```typescript
-this.scope.isDirty("title", "description");
+this.scope.isDirty(model, "firstName", "lastName");
 ```
 
 ### Validators
+
 You can create own validator using the followed template:
+
 ```typescript
-import { IValidationPropertyResult, IValidatorSetup, Validator } from "thesimplevalidation";
+import {
+  ValidationPropertyResult,
+  ValidatorSetup,
+  Validator,
+} from "thesimplevalidation";
 
 // if you need to pass extra data you can put here.
-export interface IMyValidatorSetup<TModel, K extends keyof TModel> extends IValidatorSetup<TModel, K> {
-    extraParam: () => number;
+export type MyValidatorSetup<TModel, K extends keyof TModel> = ValidatorSetup<
+  TModel,
+  K
+> & { extraParam: () => number };
+
+export class MyValidator<TModel, K extends keyof TModel> extends Validator<
+  TModel,
+  K,
+  MyValidatorSetup<TModel, K>
+> {
+  constructor(setup: MyValidatorSetup<TModel, K>) {
+    super(setup);
+  }
+
+  public async isValidInternal(
+    _value: TModel[K]
+  ): Promise<ValidationPropertyResult> {
+    let isValid: boolean = true;
+
+    //... add validation core here to set isValid
+
+    return {
+      isValid: isValid,
+      errors: [], // You can add errors here, or use `setup.getErrors` method
+    };
+  }
 }
-
-export class MyValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, IMyValidatorSetup<TModel, K>> {
-    constructor(setup: IMyValidatorSetup<TModel, K>) {
-        super(setup);
-    }
-
-    public async isValidInternal(_value: TModel[K]): Promise<IValidationPropertyResult> {
-        let isValid: boolean = true;
-
-        //... add validation core here to set isValid
-
-        return {
-            isValid: isValid,
-            errors: [] // You can add errors here, or use `setup.getErrors` method
-        };
-    }
-}
-
 ```
 
-#### `IMyValidatorSetup<TModel, K>`
+#### `MyValidatorSetup<TModel, K>`
+
 The base options of validators.
 
 `isDisabled?: (value: TModel[K]) => boolean;` is used to disable validator based on some logic-function.
@@ -212,84 +213,101 @@ Could be nice if validation logic is depended on some values, logic, etc...
 `getErrors?: (value: TModel[K]) => string[];` is used to define error messages.
 
 #### RequiredValidator
+
 Validates property against `""`, `null`, `undefined`, `0`, array.`length`.
 
 #### MinValidator
-Validates the minimum value of property. 
 
-Property value is a string then the validator checks the string length. 
+Validates the minimum value of property.
+
+Property value is a string then the validator checks the string length.
 If an array then the validator checks the array length.
 If a number then the validator validate against min value.
 
 ```typescript
 new MinValidator({
-    minValue: () => 10
+  minValue: () => 10,
 });
 ```
 
 #### MaxValidator
-Validates the maximum value of property. 
 
-Property value is a string then the validator checks the string length. 
+Validates the maximum value of property.
+
+Property value is a string then the validator checks the string length.
 If an array then the validator checks the array length.
 If a number then the validator validate against max value.
 
 ```typescript
 new MaxValidator({
-    maxValue: () => 255
+  maxValue: () => 255,
 });
 ```
 
 #### BooleanValidator
+
 Validates if the model boolean property value is the same if some boolean value
+
 ```typescript
 new MaxValidator({
-    target: () => true
+  target: () => true,
 });
 ```
 
 #### SimpleValidator
+
 The simpliest validator that option `getValidation` boolean value will be used as isValid of validation. The model property value is not used.
 See implementation:
+
 ```typescript
-export interface ISimpleValidatorSetup<TModel, K extends keyof TModel> extends IValidatorSetup<TModel, K> {
-    getValidation: () => boolean;
+export interface SimpleValidatorSetup<TModel, K extends keyof TModel>
+  extends ValidatorSetup<TModel, K> {
+  getValidation: () => boolean;
 }
 
-export class SimpleValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, ISimpleValidatorSetup<TModel, K>> {
-    constructor(setup: ISimpleValidatorSetup<TModel, K>) {
-        super(setup);
-    }
-
-    public async isValidInternal(_value: TModel[K]): Promise<IValidationPropertyResult> {
-        const isValid: boolean = this.setup.getValidation();
-
-        return {
-            isValid: isValid,
-            errors: []
-        };
-    }
+export class SimpleValidator<TModel, K extends keyof TModel> extends Validator<
+  TModel,
+  K,
+  SimpleValidatorSetup<TModel, K>
+> {
+  constructor(setup: SimpleValidatorSetup<TModel, K>) {
+    super(setup);
+  }
+
+  public async isValidInternal(
+    _value: TModel[K]
+  ): Promise<ValidationPropertyResult> {
+    const isValid: boolean = this.setup.getValidation();
+
+    return {
+      isValid: isValid,
+      errors: [],
+    };
+  }
 }
 ```
 
 Example:
+
 ```typescript
 new SimpleValidator({
-    getValidation: () => true
+  getValidation: () => true,
 });
 // -> isValid = true
 ```
+
 or
+
 ```typescript
 new SimpleValidator({
-    getValidation: () => false
+  getValidation: () => false,
 });
 // -> isValid = false
 ```
 
-
 ## Credits
-[Alexey Ripenko](http://ripenko.ru/), [GitHub](https://github.com/ripenko/)
+
+[Alexey Ripenko](https://www.linkedin.com/in/ripenko/), [GitHub](https://github.com/ripenko/)
 
 ## License
 

package/dist/Validation.d.ts

@@ -0,0 +1,16 @@
+import { ValidationPropertyResult } from "./ValidationPropertyResult";
+import { ValidationResult } from "./ValidationResult";
+import { Validator } from "./Validator";
+export declare class Validation<TModel extends {}> {
+    private originalModel;
+    private modelInfo;
+    constructor(originalModel: TModel);
+    useOriginal: (model: TModel) => Validation<TModel>;
+    useNoValidators: () => Validation<TModel>;
+    useValidators: <K extends keyof TModel>(key: K, ...validators: Array<Validator<TModel, K>>) => Validation<TModel>;
+    isPropertyDirty: (model: TModel, field: keyof TModel, key?: string | null) => boolean;
+    getOriginalProperty: <K extends keyof TModel>(field: K) => TModel[K];
+    isDirty: (model: TModel, ...fields: Array<keyof TModel>) => boolean;
+    isPropertyValid: <K extends keyof TModel>(model: TModel, field: K) => Promise<ValidationPropertyResult>;
+    isValid: (model: TModel, ...fields: Array<keyof TModel>) => Promise<ValidationResult<TModel>>;
+}

package/dist/Validation.js

@@ -0,0 +1,99 @@
+import get from "lodash.get";
+import isEqual from "lodash.isequal";
+export class Validation {
+    constructor(originalModel) {
+        this.useOriginal = (model) => {
+            this.originalModel = structuredClone(model);
+            return this;
+        };
+        this.useNoValidators = () => {
+            this.modelInfo = {};
+            return this;
+        };
+        this.useValidators = (key, ...validators) => {
+            this.modelInfo[key] = {
+                validators: validators,
+            };
+            return this;
+        };
+        this.isPropertyDirty = (model, field, key = null) => {
+            const originalField = this.originalModel[field];
+            const modelField = model[field];
+            if (Array.isArray(originalField) && Array.isArray(modelField)) {
+                if (originalField.length !== modelField.length)
+                    return true;
+                for (let index = 0; index < originalField.length; index++) {
+                    if (originalField[index] === modelField[index])
+                        continue;
+                    if (key == null)
+                        return true;
+                    if (get(originalField[index], key) !== get(modelField[index], key))
+                        return true;
+                }
+                return false;
+            }
+            if (key == null)
+                return !isEqual(this.originalModel[field], model[field]);
+            return get(this.originalModel[field], key) !== get(model[field], key);
+        };
+        this.getOriginalProperty = (field) => {
+            return this.originalModel[field];
+        };
+        this.isDirty = (model, ...fields) => {
+            for (const property in this.originalModel) {
+                if (!this.originalModel.hasOwnProperty(property))
+                    continue;
+                if (fields && fields.length > 0) {
+                    if (!fields.some((x) => x === property))
+                        continue;
+                }
+                if (this.isPropertyDirty(model, property))
+                    return true;
+            }
+            return false;
+        };
+        this.isPropertyValid = async (model, field) => {
+            if (this.modelInfo[field] &&
+                this.modelInfo[field].validators &&
+                this.modelInfo[field].validators) {
+                let isValid = true;
+                let errors = [];
+                const value = model[field];
+                for (const validator of this.modelInfo[field].validators) {
+                    const validatorResult = await validator.isValid(value, model, field);
+                    isValid = isValid && validatorResult.isValid;
+                    if (!validatorResult.isValid)
+                        errors = [...errors, ...validatorResult.errors];
+                }
+                return {
+                    isValid: isValid,
+                    errors: errors,
+                };
+            }
+            return {
+                isValid: true,
+                errors: [],
+            };
+        };
+        this.isValid = async (model, ...fields) => {
+            model = model ?? {};
+            const properties = (fields == null || fields.length === 0 ? Object.keys(model) : fields);
+            const result = {
+                isValid: true,
+                errors: [],
+                properties: {},
+            };
+            for (const property of properties) {
+                const propertyValidationResult = await this.isPropertyValid(model, property);
+                result.isValid = result.isValid && propertyValidationResult.isValid;
+                result.properties[property] = propertyValidationResult;
+                if (!propertyValidationResult.isValid)
+                    result.errors = [...result.errors, ...propertyValidationResult.errors];
+            }
+            return result;
+        };
+        this.originalModel = structuredClone(originalModel);
+        this.modelInfo = {};
+    }
+}
+//# sourceMappingURL=Validation.js.map

package/dist/Validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validation.js","sourceRoot":"","sources":["../src/Validation.ts"],"names":[],"mappings":"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"}

package/{src/validation-errors-model.ts → dist/ValidationErrorsModel.d.ts}

@@ -1,3 +1,3 @@
-export type ValidationErrorsModel<TModel> = {
-    [k in keyof TModel]: string[];
-};
+export type ValidationErrorsModel<TModel> = {
+    [k in keyof TModel]: string[];
+};

package/dist/ValidationErrorsModel.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidationErrorsModel.js.map

package/dist/ValidationErrorsModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationErrorsModel.js","sourceRoot":"","sources":["../src/ValidationErrorsModel.ts"],"names":[],"mappings":""}

package/{src/validation-model.ts → dist/ValidationModel.d.ts}

@@ -1,3 +1,3 @@
-export type ValidationModel<TModel> = {
-    [K in keyof TModel]: boolean;
-};
+export type ValidationModel<TModel> = {
+    [K in keyof TModel]: boolean;
+};

package/dist/ValidationModel.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidationModel.js.map

package/dist/ValidationModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationModel.js","sourceRoot":"","sources":["../src/ValidationModel.ts"],"names":[],"mappings":""}

package/dist/ValidationPropertyResult.d.ts

@@ -0,0 +1,4 @@
+export type ValidationPropertyResult = {
+    isValid: boolean;
+    errors: string[];
+};

package/dist/ValidationPropertyResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidationPropertyResult.js.map

package/dist/ValidationPropertyResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationPropertyResult.js","sourceRoot":"","sources":["../src/ValidationPropertyResult.ts"],"names":[],"mappings":""}

package/dist/ValidationResult.d.ts

@@ -0,0 +1,8 @@
+import { ValidationPropertyResult } from "./ValidationPropertyResult";
+export type ValidationResult<TModel> = {
+    isValid: boolean;
+    properties: {
+        [K in keyof TModel]: ValidationPropertyResult;
+    };
+    errors: string[];
+};

package/dist/ValidationResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidationResult.js.map

package/dist/ValidationResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationResult.js","sourceRoot":"","sources":["../src/ValidationResult.ts"],"names":[],"mappings":""}

package/dist/ValidationScope.d.ts

@@ -0,0 +1,15 @@
+import { ValidationPropertyResult } from "./ValidationPropertyResult";
+import { ValidationResult } from "./ValidationResult";
+import { Validator } from "./Validator";
+export declare class ValidationScope<TModel extends {}> {
+    private originalModel;
+    private modelInfo;
+    constructor(originalModel: TModel);
+    useOriginal: (model: TModel) => ValidationScope<TModel>;
+    useValidators: <K extends keyof TModel>(key: K, ...validators: Array<Validator<TModel, K>>) => ValidationScope<TModel>;
+    isPropertyDirty: (model: TModel, field: keyof TModel, key?: string | null) => boolean;
+    getOriginalProperty: <K extends keyof TModel>(field: K) => TModel[K];
+    isDirty: (model: TModel, ...fields: Array<keyof TModel>) => boolean;
+    isPropertyValid: <K extends keyof TModel>(model: TModel, field: K) => Promise<ValidationPropertyResult>;
+    isValid: (model: TModel, ...fields: Array<keyof TModel>) => Promise<ValidationResult<TModel>>;
+}