thesimplevalidation 1.0.0 → 1.0.2

package/README.md

@@ -1,355 +1,293 @@
-# localizationservice
+# thesimplevalidation
 
-The simple localization service
+The simple validation service
 
-[![Build Status](https://travis-ci.org/ripenko/localizationservice.svg?branch=master)](https://travis-ci.org/ripenko/localizationservice)
-
-Also there is `localizationkeys-webpack` that generates typescript class of localization keys. See [https://github.com/ripenko/localizationkeys-webpack].
+[![Build Status](https://travis-ci.org/ripenko/thesimplevalidation.svg?branch=master)](https://travis-ci.org/ripenko/thesimplevalidation)
 
 ## Installation
-
 ```
-npm install --save localizationservice
+npm install --save thesimplevalidation
 ```
 
-## Usage
+## Setup
+There are paar steps to enable validation.
 
-### Simple usage
-method `localize`
+### 1. Create a model
 ```typescript
-import LocalizationService from "localizationservice";
+interface IModel {
+    title: string;
+    description: string;
+}
+```
 
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
-    }
+### 2. Create or use state, or something similar where we store user model values
+```typescript
+this.model: IModel = {
+    title: "",
+    description: ""
 };
-
-const service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage
-    },
-    currentLanguage: defaultLanguage
-});
-
-const localized: string = service.localize("Key2.Key21");
-console.log(localized);  // "Value 21"
-
 ```
 
-### Example. The facade pattern with event bus integration
-The events bus is `eventservice`. See [https://github.com/ripenko/eventservice]
-
-There are two localization files `default.jsonc` and `de-de.json`. To generate localization keys from `default.jsonc` file we can use webpack plugin [https://github.com/ripenko/localizationkeys-webpack].
-
-The `Localization.ts` file in your app.
+### 3. Create validation model, validation errors model
 ```typescript
-import LocalizationService from "localizationservice";
-import EventService from "eventservice";
+import { ValidationModel } from "thesimplevalidation";
 
-export default class Localization {
-       
-    private static service: LocalizationService | null = null;
-
-    public static localize<T = string>(key: string, ...formatArgs: string[]): T {
-        if (Localization.service == null) initService();
-        return Localization.service.localize(key, formatArgs);
-    }
+this.validation: ValidationModel<IModel> = {
+    title: false,
+    description: true
+};
 
-    private static initService(): void {
-        const defaultLanguage = require("localization/default.jsonc");
-        const germanLanguage = require("localization/de-de.jsonc");
-        Localization.service = new LocalizationService({
-            importedLanguages: {
-                [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage,
-                "de-de": germanLanguage
-            },
-            onLanguageChanged: (languageName: string, language: ILocalizationLanguage): Promise<void> => {
-                // we can notify subscribers that the current language has been changed.
-                // if we use momentjs then we can change locale by `moment.locale(languageName);`
-                // or numeraljs, etc...
-                return EventService.fire("Events.Localization.LanguageChanged", { name: languageName, langauge: language });
-            },
-            onLanguageImported: (languageName: string, language: ILocalizationLanguage): Promise<void> => {
-                // we can load language from api or some another place async to import it by `service.importLanguage` method
-                // when new language will be imported we can update UI by refreshing a list of available languages
-                return EventService.fire("Events.Localization.LanguageImported", { name: languageName, langauge: language });
-            },
-            onLocalizationMissing: (key: string, _languageName: string, _language: ILocalizationLanguage | null, _formatArgs: string[]): string => {
-                // When localization has been not found in current language we return just key. 
-                // The testers could find easy such unlocalizated places.
-                // Or we can notify insights about missing values.
-                // Or we can try to get value from default language.
-                // Or write in the console, etc...
-                return key;
-            }
-        });
-    }
+this.validationErrors: ValidationErrorsModel<IModel> = {
+    title: [];
+    description: [];
+};
 
-}
+this.allValidationErrors: string [] = [];
 
+this.isValid: boolean = false;
 ```
 
-### Return localized object instead of certain string
-Method `localize`. By default return type of method `localize<T = string>` is string.
-If we pass a localization key that point doesn't point to string, but it points to the parent nested object, then localized result will be object.
-Typically usecases: 
-
-- dynamic key. if localization key is computed
-- localized object should be passed to some component. (Example: Globalization, or localization of some Telerik control)
 
+### 4. Creating Validation Scope
 ```typescript
-import LocalizationService from "localizationservice";
+import { ValidationScope } from "thesimplevalidation";
 
-interface IFeatureString {
-    Title: string;
-    Description: string;
-}
+const scope = new ValidationScope<IModel>({
+    getModel: (): IModel => this.model
+});
 
-const defaultLanguage = {
-    "Feature": {
-        "Title": "Some Title",
-        "Description": "Some Description"
-    }
-};
+```
 
-const service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage
-    },
-    currentLanguage: defaultLanguage
-});
+### 5. 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";
 
-const result: IFeatureString = service.localize<IFeatureString>("Feature");
-console.log(result); // -> { Title: "Some Title", Description: "Some Description" }
+this.scope.useValidators("title", new RequiredValidator());
 
 ```
 
-### Changing the current language
-method `changeLanguage`
+### 6. Do validation
 ```typescript
-import LocalizationService from "localizationservice";
+const result: IValidationResult<IModel> = await this.scope.isValid();
+console.log(result.isValid, result); 
+// -> false, { isValid: false, properties: { title: { isValid: false, errors: [] }, description: { isValid: true, errors: [] } }, errors: [] }
+```
 
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
-    }
-};
+## Usage
 
-const germanLanguage = {
-    "Key1": "Wert 1",
-    "Key2": {
-        "Key21": "Wert 21"
+### ValidationScope
+This class is main point to define validation. Possible to define more than one scope 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 service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage,
-        "de-de": germanLanguage
-    },
-    currentLanguage: defaultLanguage
 });
-
-await service.changeLanguage("de-DE"); // language name case will be lowered => de-de
-
-const localized: string = service.localize("Key2.Key21");
-console.log(localized);  // "Wert 21"
-
 ```
+`getModel` is invoked on validation by method `isValid`.
+`onValidationChanged` Optional. To handle validation result. It is invoked before `isValid` method is completed.
 
-### Using onChangeLanguage handler. When the current language has been changed
-method `changeLanguage` and constructor options property `onChangeLanguage`.
+### `isValid`
+Validates the whole model.
 ```typescript
-import LocalizationService from "localizationservice";
-
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
-    }
-};
-
-const germanLanguage = {
-    "Key1": "Wert 1",
-    "Key2": {
-        "Key21": "Wert 21"
-    }
-}
+const result: IValidationResult<IModel> = await this.scope.isValid();
+console.log(result.isValid); // -> false
+```
 
-const service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage,
-        "de-de": germanLanguage
-    },
-    currentLanguage: defaultLanguage,
-    onChangeLanguage: async (languageName: string, language: ILocalizationLanguage | null): Promise<void> => {
-        console.info(languageName, language);
-    }
-});
+#### `isPropertyValid`
+Validates only a specific property.
+```typescript
+const propertyResult: IValidationPropertyResult = await this.scope.isPropertyValid("description");
+console.log(propertyResult.isValid); // -> false
+```
 
-await service.changeLanguage("de-DE"); // language name case will be lowered => de-de
-// -> de-de { Key1: "Wert 1", Key2: { Key21: "Wert 21" } }
+#### `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
+);
+```
 
+#### `useOriginal`
+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);
 ```
 
-### Importing new language using language property `__cultureName__`
-method `importLanguage`.
+#### `isPropertyDirty`
+The method of the validation scope allows to check if property has been changed (dirty).
 ```typescript
-import LocalizationService from "localizationservice";
+this.model.title = "New Title";
+let isTitleDirty: boolean = this.scope.isPropertyDirty("title");
+console.log(isTitleDirty); // -> true
 
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
-    }
-};
+this.scope.useOriginal(this.model);
+isTitleDirty = this.scope.isPropertyDirty("title");
+console.log(isTitleDirty); // -> false
+```
 
-const germanLanguage = {
-    __cultureName__: "de-de",
-    "Key1": "Wert 1",
-    "Key2": {
-        "Key21": "Wert 21"
-    }
-}
+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`.
 
-const service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage
-    },
-    currentLanguage: defaultLanguage
-});
 
-// `__cultureName__` of `germanLanguage` will be used to definde language name
-// The method doesn't change the current language. See `changeLanguage`.
-// The language name detection priority is language property `__cultureName__`, 
-// if there is no, then parameter `name`. If the parameter `name` is undefined,
-// then `LocalizationService.DEFAULT_CULTURE_NAME`
-await service.importLanguage(germanLanguage);
+#### `getOriginalProperty`
+Gets property from saved cloned model.
+```typescript
+const originalTitle = this.scope.getOriginalProperty("title");
+```
 
-const localized: string = service.localize("Key2.Key21");
-console.log(localized);  // "Value 21"
+#### `isDirty`
+Checks if model or model properties have been changed (dirty).
 
+Checks the whole model
+```typescript
+this.scope.isDirty();
+```
+or checks only `title` property
+```typescript
+this.scope.isDirty("title");
+```
+or checks multiple properties
+```typescript
+this.scope.isDirty("title", "description");
 ```
 
-### Importing new language using optional method parameter `name`
-method `importLanguage`.
+### Validators
+You can create own validator using the followed template:
 ```typescript
-import LocalizationService from "localizationservice";
+import { IValidationPropertyResult, IValidatorSetup, 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;
+}
 
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
+export class MyValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, IMyValidatorSetup<TModel, K>> {
+    constructor(setup: IMyValidatorSetup<TModel, K>) {
+        super(setup);
     }
-};
 
-const germanLanguage = {
-    "Key1": "Wert 1",
-    "Key2": {
-        "Key21": "Wert 21"
+    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
+        };
     }
 }
 
-const service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage
-    },
-    currentLanguage: defaultLanguage
-});
+```
 
-// There is no `__cultureName__` of `germanLanguage`, 
-// then parameter `name` will be used to definde language name `de-de` (case will be lowered).
-// The method doesn't change the current language. See `changeLanguage`.
-await service.importLanguage(germanLanguage, "de-DE");
+#### `IMyValidatorSetup<TModel, K>`
+The base options of validators.
 
-const localized: string = service.localize("Key2.Key21");
-console.log(localized);  // "Value 21"
+`isDisabled?: (value: TModel[K]) => boolean;` is used to disable validator based on some logic-function.
+Could be nice if validation logic is depended on some values, logic, etc...
 
-```
+`getErrors?: (value: TModel[K]) => string[];` is used to define error messages.
 
-### Importing new default language
-method `importLanguage`.
-```typescript
-import LocalizationService from "localizationservice";
+#### RequiredValidator
+Validates property against `""`, `null`, `undefined`, `0`, array.`length`.
 
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
-    }
-};
+#### MinValidator
+Validates the minimum value of property. 
 
-const germanLanguage = {
-    "Key1": "Wert 1",
-    "Key2": {
-        "Key21": "Wert 21"
-    }
-}
+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.
 
-const service = new LocalizationService({
-    importedLanguages: {
-        [LocalizationService.DEFAULT_CULTURE_NAME]: defaultLanguage
-    },
-    currentLanguage: defaultLanguage
+```typescript
+new MinValidator({
+    minValue: () => 10
 });
+```
 
-// `__cultureName__` of `germanLanguage` will be used to definde language name
-// The method doesn't change the current language. See `changeLanguage`.
-await service.importLanguage(germanLanguage);
-
-// To apply updated language you have to refresh current language
-await service.changeLanguage();
+#### MaxValidator
+Validates the maximum value of property. 
 
-const localized: string = service.localize("Key2.Key21");
-console.log(localized);  // "Wert 21"
+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
+});
 ```
 
-### Using on `onLanguageImported` handler. When the language has been imported.
-constructor option `onLanguageImported` or property `onLanguageImported`.
+#### BooleanValidator
+Validates if the model boolean property value is the same if some boolean value
 ```typescript
-import LocalizationService from "localizationservice";
+new MaxValidator({
+    target: () => true
+});
+```
 
-const defaultLanguage = {
-    "Key1": "Value 1",
-    "Key2": {
-        "Key21": "Value 21"
-    }
-};
+#### 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;
+}
 
-const service = new LocalizationService({
-    onLanguageImported: async (name: string, language: ILocalizationLanguage): Promise<void> => {
-        console.log(name, language);
+export class SimpleValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, ISimpleValidatorSetup<TModel, K>> {
+    constructor(setup: ISimpleValidatorSetup<TModel, K>) {
+        super(setup);
     }
-});
 
-// `__cultureName__` of `defaultLanguage` will be used to definde language name
-// The method doesn't change the current language. See `changeLanguage`.
-await service.importLanguage(defaultLanguage);
-// -> "" { Key1: "Value 1", Key2: { Key21: "Value 21" } }
+    public async isValidInternal(_value: TModel[K]): Promise<IValidationPropertyResult> {
+        const isValid: boolean = this.setup.getValidation();
 
+        return {
+            isValid: isValid,
+            errors: []
+        };
+    }
+}
 ```
 
-### Using on `onLocalizationMissing` handler. When localization string has been not found
-constructor option `onLocalizationMissing` or property `onLocalizationMissing`.
+Example:
 ```typescript
-import LocalizationService from "localizationservice";
-
-const service = new LocalizationService({
-    // name will be `LocalizationService.DEFAULT_CULTURE_NAME`, language is `{}`
-    onLocalizationMissing: (key: string, name: string, language: ILocalizationLanguage): string => {
-        return `Missed '${key}' for default language`;
-    }
+new SimpleValidator({
+    getValidation: () => true
 });
-
-const result: string = service.localize("SomeKey");
-console.log(result); // -> "Missed 'SomeKey' for default language"
-
+// -> isValid = true
+```
+or
+```typescript
+new SimpleValidator({
+    getValidation: () => false
+});
+// -> isValid = false
 ```
 
+
 ## Credits
 [Alexey Ripenko](http://ripenko.ru/), [GitHub](https://github.com/ripenko/)
 

package/dist/index.d.ts

@@ -1 +1 @@
-export * from "./src";
+export * from "./src";

package/dist/index.js

@@ -1,7 +1,18 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./src"));
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;AAAA,2BAAsB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB"}

package/dist/src/index.d.ts

@@ -1,8 +1,8 @@
-export { ValidationScope } from "./validation-scope";
-export { ValidationErrorsModel } from "./validation-errors-model";
-export { ValidationModel } from "./validation-model";
-export { IValidationPropertyResult } from "./validation-property-result";
-export { IValidationResult } from "./validation-result";
-export { Validator } from "./validator";
-export { IValidatorSetup } from "./validator-setup";
-export * from "./validators";
+export { ValidationScope } from "./validation-scope";
+export { ValidationErrorsModel } from "./validation-errors-model";
+export { ValidationModel } from "./validation-model";
+export { IValidationPropertyResult } from "./validation-property-result";
+export { IValidationResult } from "./validation-result";
+export { Validator } from "./validator";
+export { IValidatorSetup } from "./validator-setup";
+export * from "./validators";

package/dist/src/index.js

@@ -1,11 +1,23 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var validation_scope_1 = require("./validation-scope");
-exports.ValidationScope = validation_scope_1.ValidationScope;
-var validator_1 = require("./validator");
-exports.Validator = validator_1.Validator;
-__export(require("./validators"));
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = exports.ValidationScope = void 0;
+var validation_scope_1 = require("./validation-scope");
+Object.defineProperty(exports, "ValidationScope", { enumerable: true, get: function () { return validation_scope_1.ValidationScope; } });
+var validator_1 = require("./validator");
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validator_1.Validator; } });
+__exportStar(require("./validators"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;AAAA,uDAAqD;AAA5C,6CAAA,eAAe,CAAA;AAKxB,yCAAwC;AAA/B,gCAAA,SAAS,CAAA;AAGlB,kCAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AAKxB,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAGlB,+CAA6B"}