feat(stark-core): update class-validator dependency to version ~0.13.1

BREAKING CHANGE:

Due to class-validator update:
  - Validatorjs releases contain some breaking changes e.g. `IsMobileNumber` or `IsHexColor`. Please
check validatorjs [CHANGELOG](https://github.com/validatorjs/validator.js/blob/master/CHANGELOG.md)
  - Validation functions was removed from `Validator` class to enable tree shaking.

    BEFORE:

    ```ts
    import { Validator } from 'class-validator';

    const validator = new Validator();
    validator.isNotIn(value, possibleValues);
    validator.isBoolean(value);
    ```

    AFTER:

    ```ts
    import { isNotIn, isBoolean } from 'class-validator';

    isNotIn(value, possibleValues);
    isBoolean(value);
    ```

  - IsNumberString decorator arguments changed to
  `@IsNumberString(ValidatorJS.IsNumericOptions, ValidationOptions)`.

packages/stark-core/package.json

@@ -31,7 +31,7 @@
     "@uirouter/core": "^6.0.0",
     "@uirouter/rx": "^0.6.0",
     "cerialize": "^0.1.18",
-    "class-validator": "~0.11.0",
+    "class-validator": "~0.13.1",
     "deep-freeze-strict": "^1.1.1",
     "ibantools": "^3.2.3",
     "lodash-es": "^4.17.21",

packages/stark-core/src/util/validation-errors.util.spec.ts

@@ -74,7 +74,9 @@ describe("Util: ValidationErrorsUtil", () => {
 			myClass.languages.push(new LanguageClass("french", "")); // invalid description
 			const errors: ValidationError[] = validateSync(myClass);
 			expect(errors.length).toBe(1);
-			expect(errors[0].children.length).toBe(myClass.languages.length);
+			expect(errors[0].children).toBeDefined();
+			// tslint:disable-next-line:no-non-null-assertion
+			expect(errors[0].children!.length).toBe(myClass.languages.length);
 
 			try {
 				StarkValidationErrorsUtil.throwOnError(errors);

packages/stark-core/src/validation/decorators/is-bban/is-bban.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsBBAN } from "./is-bban.validator.decorator";
 import { starkIsBBANValidatorName } from "../../validators/is-bban";
@@ -41,15 +41,15 @@ describe("ValidatorDecorator: StarkIsBBAN", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if bban is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if belgian bban is not correct", () => {
@@ -65,7 +65,7 @@ describe("ValidatorDecorator: StarkIsBBAN", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should NOT fail if belgian bban is correct", () => {

packages/stark-core/src/validation/decorators/is-bic/is-bic.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsBIC } from "./is-bic.validator.decorator";
 import { starkIsBICValidatorName } from "../../validators/is-bic";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkIsBIC", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if bic is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if bic is not correct", () => {

packages/stark-core/src/validation/decorators/is-company-number/is-company-number.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsCompanyNumber } from "./is-company-number.validator.decorator";
 import { starkIsCompanyNumberValidatorName } from "../../validators/is-company-number";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkIsCompanyNumber", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if company number is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if company number is not correct", () => {

packages/stark-core/src/validation/decorators/is-establishment-unit-number/is-establishment-unit-number.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsEstablishmentUnitNumber } from "./is-establishment-unit-number.validator.decorator";
 import { starkIsEstablishmentUnitNumberValidatorName } from "../../validators/is-establishment-unit-number";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkIsEstablishmentUnitNumber", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if company number is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if company number is not correct", () => {

packages/stark-core/src/validation/decorators/is-iban/is-iban.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsIBAN } from "./is-iban.validator.decorator";
 import { starkIsIBANValidatorName } from "../../validators/is-iban";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkIsIBAN", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if iban is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if iban is not correct", () => {

packages/stark-core/src/validation/decorators/is-isin/is-isin.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsISIN } from "./is-isin.validator.decorator";
 import { starkIsISINValidatorName } from "../../validators/is-isin";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkIsISIN", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if isin is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if isin is not correct", () => {

packages/stark-core/src/validation/decorators/is-kbo/is-kbo.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsKBO } from "./is-kbo.validator.decorator";
 import { starkIsKBOValidatorName } from "../../validators/is-kbo";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkIsKBO", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if kbo is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if kbo is not correct", () => {

packages/stark-core/src/validation/decorators/is-nin/is-nin.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs no-identical-functions*/
+/* tslint:disable:completed-docs no-identical-functions no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsNIN } from "./is-nin.validator.decorator";
 import { starkIsNINValidatorName } from "../../validators/is-nin";
@@ -41,15 +41,15 @@ describe("ValidatorDecorator: StarkIsNIN", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if nin is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if belgian nin is not correct", () => {
@@ -65,7 +65,7 @@ describe("ValidatorDecorator: StarkIsNIN", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should NOT fail if belgian nin is correct", () => {

packages/stark-core/src/validation/decorators/is-supported-language/is-supported-language.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs*/
+/* tslint:disable:completed-docs no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkIsSupportedLanguage } from "./is-supported-language.validator.decorator";
 import { starkIsSupportedLanguageValidatorName } from "../../validators/is-supported-language";
@@ -21,7 +21,7 @@ describe("ValidatorDecorator: StarkIsSupportedLanguage", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if language is not in the list of supported languages", () => {
@@ -30,7 +30,7 @@ describe("ValidatorDecorator: StarkIsSupportedLanguage", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should NOT fail if language is in the list of supported languages", () => {

packages/stark-core/src/validation/decorators/map-is-valid/map-is-valid.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs*/
+/* tslint:disable:completed-docs no-non-null-assertion */
 import { IsNotEmpty, MaxLength, validateSync, ValidationError } from "class-validator";
 import { StarkMapIsValid, starkMapIsValidValidatorName } from "./map-is-valid.validator.decorator";
 
@@ -41,7 +41,7 @@ describe("ValidatorDecorator: StarkMapIsValid", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if Map contains invalid keys", () => {
@@ -53,9 +53,9 @@ describe("ValidatorDecorator: StarkMapIsValid", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toContain("map keys");
-		expect(errors[0].constraints[validatorConstraintName]).not.toContain("map values");
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toContain("map keys");
+		expect(errors[0].constraints![validatorConstraintName]).not.toContain("map values");
 	});
 
 	it("should fail if Map contains invalid values", () => {
@@ -66,9 +66,9 @@ describe("ValidatorDecorator: StarkMapIsValid", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).not.toContain("map keys");
-		expect(errors[0].constraints[validatorConstraintName]).toContain("map values");
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).not.toContain("map keys");
+		expect(errors[0].constraints![validatorConstraintName]).toContain("map values");
 	});
 
 	it("should NOT fail if Map contains valid keys and values", () => {

packages/stark-core/src/validation/decorators/map-not-empty/map-not-empty.validator.decorator.spec.ts

@@ -1,4 +1,4 @@
-/*tslint:disable:completed-docs*/
+/* tslint:disable:completed-docs no-non-null-assertion */
 import { validateSync, ValidationError } from "class-validator";
 import { StarkMapNotEmpty } from "./map-not-empty.validator.decorator";
 import { starkMapNotEmptyValidatorName } from "../../validators/map-not-empty";
@@ -28,15 +28,15 @@ describe("ValidatorDecorator: StarkMapNotEmpty", () => {
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should fail if Map is empty", () => {
 		const errors: ValidationError[] = validateSync(myClass);
 
 		expect(errors.length).toBe(1);
 		expect(errors[0].constraints).toBeDefined();
-		expect(errors[0].constraints[validatorConstraintName]).toBeDefined();
+		expect(errors[0].constraints![validatorConstraintName]).toBeDefined();
 	});
 
 	it("should NOT fail if Map is not empty", () => {