Enable strict compiler option

keito-jp · keito-jp · commit b9d4840d2be2 · 2018-10-02T14:34:30.000+09:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/interfaces.ts b/src/interfaces.ts
@@ -14,7 +14,7 @@ import {
 
 export interface IValidator<T, U> {
   definition: U;
-  validate: (input: T) => IValidationError<T, U>;
+  validate: (input: T) => IValidationError<T, U> | null;
 }
 
 export interface IBaseValidatorDefinition {
diff --git a/src/validators/enum.ts b/src/validators/enum.ts
@@ -4,15 +4,14 @@ import {
 } from "../errors";
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IEnumValidatorDefinition<T> extends IBaseValidatorDefinition {
   enum: T[];
 }
 
-export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition<T>> {
+export class EnumValidator<T> implements IValidator<T | null, IEnumValidatorDefinition<T>> {
   constructor(public definition: IEnumValidatorDefinition<T>) {
     this.definition.type = "enum";
     const len = this.definition.enum.length;
@@ -30,7 +29,7 @@ export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition
     }
   }
 
-  public validate(input: T): IValidationError<T, IEnumValidatorDefinition<T>> {
+  public validate(input: T | null) {
     const err = {
       definition: this.definition,
       input,
@@ -40,7 +39,7 @@ export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition
     }
     for (const e of this.definition.enum) {
       if (e === input) {
-        return;
+        return null;
       }
     }
     return err;
diff --git a/src/validators/format.ts b/src/validators/format.ts
@@ -3,15 +3,14 @@ import {
 } from "../errors";
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IFormatValidatorDefinition extends IBaseValidatorDefinition {
   format: string;
 }
 
-export class FormatValidator implements IValidator<string, IFormatValidatorDefinition> {
+export class FormatValidator implements IValidator<string | null, IFormatValidatorDefinition> {
   private static rDateTime: RegExp = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.?\d{1,9})?(?:[+-]\d{2}:\d{2}|Z)/;
   private static rEmail: RegExp = /^.+@.+\..+$/;
   private static rUri: RegExp = /^[0-9a-zA-Z]+:\/\/.+$/;
@@ -31,7 +30,7 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin
     }
   }
 
-  public validate(input: string): IValidationError<string, IFormatValidatorDefinition> {
+  public validate(input: string | null) {
     const err = {
       definition: this.definition,
       input,
@@ -45,31 +44,31 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin
     switch (format) {
       case "date-time": {
         if (FormatValidator.rDateTime.test(input)) {
-          return;
+          return null;
         }
         break;
       }
       case "email": {
         if (FormatValidator.rEmail.test(input)) {
-          return;
+          return null;
         }
         break;
       }
       case "hostname": {
         if (this.isHostName(input)) {
-          return;
+          return null;
         }
         break;
       }
       case "uri": {
         if (FormatValidator.rUri.test(input)) {
-          return;
+          return null;
         }
         break;
       }
       case "password-0Aa": {
         if (this.isPassword0Aa(input)) {
-          return;
+          return null;
         }
         break;
       }
diff --git a/src/validators/max_items.ts b/src/validators/max_items.ts
@@ -4,15 +4,14 @@ import {
 import {
   IBaseValidatorDefinition,
   IHasLength,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IMaxItemsValidatorDefinition extends IBaseValidatorDefinition {
   maxItems: number;
 }
 
-export class MaxItemsValidator implements IValidator<any, IMaxItemsValidatorDefinition> {
+export class MaxItemsValidator implements IValidator<IHasLength | null, IMaxItemsValidatorDefinition> {
   constructor(public definition: IMaxItemsValidatorDefinition) {
     this.definition.type = "max_items";
     const {maxItems} = this.definition;
@@ -21,7 +20,7 @@ export class MaxItemsValidator implements IValidator<any, IMaxItemsValidatorDefi
     }
   }
 
-  public validate(input: IHasLength): IValidationError<any, IMaxItemsValidatorDefinition> {
+  public validate(input: IHasLength | null) {
     const err = {
       definition: this.definition,
       input,
@@ -30,7 +29,7 @@ export class MaxItemsValidator implements IValidator<any, IMaxItemsValidatorDefi
       return err;
     }
     if (input.length <= this.definition.maxItems) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/max_length.ts b/src/validators/max_length.ts
@@ -3,23 +3,22 @@ import {
 } from "../errors";
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IMaxLengthValidatorDefinition extends IBaseValidatorDefinition {
   maxLength: number;
 }
 
-export class MaxLengthValidator implements IValidator<string, IMaxLengthValidatorDefinition> {
+export class MaxLengthValidator implements IValidator<string | null, IMaxLengthValidatorDefinition> {
   constructor(public definition: IMaxLengthValidatorDefinition) {
     this.definition.type = "max_length";
     if (this.definition.maxLength < 0) {
       throw new NoLengthError(`the max length should be greater than, or equal to, 0`);
     }
   }
 
-  public validate(input: string): IValidationError<string, IMaxLengthValidatorDefinition> {
+  public validate(input: string | null) {
     const err = {
       definition: this.definition,
       input,
@@ -28,7 +27,7 @@ export class MaxLengthValidator implements IValidator<string, IMaxLengthValidato
       return err;
     }
     if (input.length <= this.definition.maxLength) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/maximum.ts b/src/validators/maximum.ts
@@ -1,6 +1,5 @@
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
@@ -9,12 +8,12 @@ export interface IMaximumValidatorDefinition extends IBaseValidatorDefinition {
   exclusive: boolean;
 }
 
-export class MaximumValidator implements IValidator<number, IMaximumValidatorDefinition> {
+export class MaximumValidator implements IValidator<number | null, IMaximumValidatorDefinition> {
   constructor(public definition: IMaximumValidatorDefinition) {
     this.definition.type = "maximum";
   }
 
-  public validate(input: number): IValidationError<number, IMaximumValidatorDefinition> {
+  public validate(input: number | null) {
     const err = {
       definition: this.definition,
       input,
@@ -25,13 +24,13 @@ export class MaximumValidator implements IValidator<number, IMaximumValidatorDef
 
     if (!this.definition.exclusive) {
       if (input <= this.definition.maximum) {
-        return;
+        return null;
       }
       return err;
     }
 
     if (input < this.definition.maximum) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/min_items.ts b/src/validators/min_items.ts
@@ -4,15 +4,14 @@ import {
 import {
   IBaseValidatorDefinition,
   IHasLength,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IMinItemsValidatorDefinition extends IBaseValidatorDefinition {
   minItems: number;
 }
 
-export class MinItemsValidator implements IValidator<any, IMinItemsValidatorDefinition> {
+export class MinItemsValidator implements IValidator<IHasLength | null, IMinItemsValidatorDefinition> {
   constructor(public definition: IMinItemsValidatorDefinition) {
     this.definition.type = "min_items";
     const {minItems} = this.definition;
@@ -21,7 +20,7 @@ export class MinItemsValidator implements IValidator<any, IMinItemsValidatorDefi
     }
   }
 
-  public validate(input: IHasLength): IValidationError<any, IMinItemsValidatorDefinition> {
+  public validate(input: IHasLength | null) {
     const err = {
       definition: this.definition,
       input,
@@ -30,7 +29,7 @@ export class MinItemsValidator implements IValidator<any, IMinItemsValidatorDefi
       return err;
     }
     if (input.length >= this.definition.minItems) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/min_length.ts b/src/validators/min_length.ts
@@ -3,23 +3,22 @@ import {
 } from "../errors";
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IMinLengthValidatorDefinition extends IBaseValidatorDefinition {
   minLength: number;
 }
 
-export class MinLengthValidator implements IValidator<string, IMinLengthValidatorDefinition> {
+export class MinLengthValidator implements IValidator<string | null, IMinLengthValidatorDefinition> {
   constructor(public definition: IMinLengthValidatorDefinition) {
     this.definition.type = "min_length";
     if (this.definition.minLength < 0) {
       throw new NoLengthError(`the minimum length should be greater than, or equal to, 0`);
     }
   }
 
-  public validate(input: string): IValidationError<string, IMinLengthValidatorDefinition> {
+  public validate(input: string | null) {
     const err = {
       definition: this.definition,
       input,
@@ -28,7 +27,7 @@ export class MinLengthValidator implements IValidator<string, IMinLengthValidato
       return err;
     }
     if (input.length >= this.definition.minLength) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/minimum.ts b/src/validators/minimum.ts
@@ -1,6 +1,5 @@
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
@@ -9,12 +8,12 @@ export interface IMinimumValidatorDefinition extends IBaseValidatorDefinition {
   exclusive: boolean;
 }
 
-export class MinimumValidator implements IValidator<number, IMinimumValidatorDefinition> {
+export class MinimumValidator implements IValidator<number | null, IMinimumValidatorDefinition> {
   constructor(public definition: IMinimumValidatorDefinition) {
     this.definition.type = "minimum";
   }
 
-  public validate(input: number): IValidationError<number, IMinimumValidatorDefinition> {
+  public validate(input: number | null) {
     const err = {
       definition: this.definition,
       input,
@@ -25,13 +24,13 @@ export class MinimumValidator implements IValidator<number, IMinimumValidatorDef
 
     if (!this.definition.exclusive) {
       if (input >= this.definition.minimum) {
-        return;
+        return null;
       }
       return err;
     }
 
     if (input > this.definition.minimum) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/pattern.ts b/src/validators/pattern.ts
@@ -4,15 +4,14 @@ import {
 } from "../errors";
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export interface IPatternValidatorDefinition extends IBaseValidatorDefinition {
   pattern: string;
 }
 
-export class PatternValidator implements IValidator<string, IPatternValidatorDefinition> {
+export class PatternValidator implements IValidator<string | null, IPatternValidatorDefinition> {
   private regExp: RegExp;
 
   constructor(public definition: IPatternValidatorDefinition) {
@@ -28,7 +27,7 @@ export class PatternValidator implements IValidator<string, IPatternValidatorDef
     }
   }
 
-  public validate(input: string): IValidationError<string, IPatternValidatorDefinition> {
+  public validate(input: string | null) {
     const err = {
       definition: this.definition,
       input,
@@ -37,7 +36,7 @@ export class PatternValidator implements IValidator<string, IPatternValidatorDef
       return err;
     }
     if (this.regExp.test(input)) {
-      return;
+      return null;
     }
     return err;
   }
diff --git a/src/validators/present.ts b/src/validators/present.ts
@@ -6,13 +6,12 @@ import {
 
 import {
   IBaseValidatorDefinition,
-  IValidationError,
   IValidator,
 } from "../interfaces";
 
 export type IPresentValidatorDefinition = IBaseValidatorDefinition;
 
-export class PresentValidator implements IValidator<any, IPresentValidatorDefinition> {
+export class PresentValidator<T> implements IValidator<T | null, IPresentValidatorDefinition> {
   /**
    * Based on `[:space:]` defined in POSIX character classes.
    */
@@ -22,7 +21,7 @@ export class PresentValidator implements IValidator<any, IPresentValidatorDefini
     this.definition.type = "present";
   }
 
-  public validate(input: any): IValidationError<any, IPresentValidatorDefinition> {
+  public validate(input: T | null) {
     const err = {
       definition: this.definition,
       input,
@@ -35,6 +34,6 @@ export class PresentValidator implements IValidator<any, IPresentValidatorDefini
     ) {
       return err;
     }
-    return;
+    return null;
   }
 }
diff --git a/src/validators/required.ts b/src/validators/required.ts
diff --git a/tsconfig.json b/tsconfig.json

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ import {`
`14`	`14`
`15`	`15`	`export interface IValidator<T, U> {`
`16`	`16`	`definition: U;`
`17`		`- validate: (input: T) => IValidationError<T, U>;`
	`17`	`+ validate: (input: T) => IValidationError<T, U> \| null;`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`export interface IBaseValidatorDefinition {`
Original file line number	Diff line number	Diff line change
`@@ -4,15 +4,14 @@ import {`
`4`	`4`	`} from "../errors";`
`5`	`5`	`import {`
`6`	`6`	`IBaseValidatorDefinition,`
`7`		`- IValidationError,`
`8`	`7`	`IValidator,`
`9`	`8`	`} from "../interfaces";`
`10`	`9`
`11`	`10`	`export interface IEnumValidatorDefinition<T> extends IBaseValidatorDefinition {`
`12`	`11`	`enum: T[];`
`13`	`12`	`}`
`14`	`13`
`15`		`-export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition<T>> {`
	`14`	`+export class EnumValidator<T> implements IValidator<T \| null, IEnumValidatorDefinition<T>> {`
`16`	`15`	`constructor(public definition: IEnumValidatorDefinition<T>) {`
`17`	`16`	`this.definition.type = "enum";`
`18`	`17`	`const len = this.definition.enum.length;`
`@@ -30,7 +29,7 @@ export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition`
`30`	`29`	`}`
`31`	`30`	`}`
`32`	`31`
`33`		`- public validate(input: T): IValidationError<T, IEnumValidatorDefinition<T>> {`
	`32`	`+ public validate(input: T \| null) {`
`34`	`33`	`const err = {`
`35`	`34`	`definition: this.definition,`
`36`	`35`	`input,`
`@@ -40,7 +39,7 @@ export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition`
`40`	`39`	`}`
`41`	`40`	`for (const e of this.definition.enum) {`
`42`	`41`	`if (e === input) {`
`43`		`- return;`
	`42`	`+ return null;`
`44`	`43`	`}`
`45`	`44`	`}`
`46`	`45`	`return err;`
Original file line number	Diff line number	Diff line change
`@@ -3,15 +3,14 @@ import {`
`3`	`3`	`} from "../errors";`
`4`	`4`	`import {`
`5`	`5`	`IBaseValidatorDefinition,`
`6`		`- IValidationError,`
`7`	`6`	`IValidator,`
`8`	`7`	`} from "../interfaces";`
`9`	`8`
`10`	`9`	`export interface IFormatValidatorDefinition extends IBaseValidatorDefinition {`
`11`	`10`	`format: string;`
`12`	`11`	`}`
`13`	`12`
`14`		`-export class FormatValidator implements IValidator<string, IFormatValidatorDefinition> {`
	`13`	`+export class FormatValidator implements IValidator<string \| null, IFormatValidatorDefinition> {`
`15`	`14`	`private static rDateTime: RegExp = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.?\d{1,9})?(?:[+-]\d{2}:\d{2}\|Z)/;`
`16`	`15`	`private static rEmail: RegExp = /^.+@.+\..+$/;`
`17`	`16`	`private static rUri: RegExp = /^[0-9a-zA-Z]+:\/\/.+$/;`
`@@ -31,7 +30,7 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin`
`31`	`30`	`}`
`32`	`31`	`}`
`33`	`32`
`34`		`- public validate(input: string): IValidationError<string, IFormatValidatorDefinition> {`
	`33`	`+ public validate(input: string \| null) {`
`35`	`34`	`const err = {`
`36`	`35`	`definition: this.definition,`
`37`	`36`	`input,`
`@@ -45,31 +44,31 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin`
`45`	`44`	`switch (format) {`
`46`	`45`	`case "date-time": {`
`47`	`46`	`if (FormatValidator.rDateTime.test(input)) {`
`48`		`- return;`
	`47`	`+ return null;`
`49`	`48`	`}`
`50`	`49`	`break;`
`51`	`50`	`}`
`52`	`51`	`case "email": {`
`53`	`52`	`if (FormatValidator.rEmail.test(input)) {`
`54`		`- return;`
	`53`	`+ return null;`
`55`	`54`	`}`
`56`	`55`	`break;`
`57`	`56`	`}`
`58`	`57`	`case "hostname": {`
`59`	`58`	`if (this.isHostName(input)) {`
`60`		`- return;`
	`59`	`+ return null;`
`61`	`60`	`}`
`62`	`61`	`break;`
`63`	`62`	`}`
`64`	`63`	`case "uri": {`
`65`	`64`	`if (FormatValidator.rUri.test(input)) {`
`66`		`- return;`
	`65`	`+ return null;`
`67`	`66`	`}`
`68`	`67`	`break;`
`69`	`68`	`}`
`70`	`69`	`case "password-0Aa": {`
`71`	`70`	`if (this.isPassword0Aa(input)) {`
`72`		`- return;`
	`71`	`+ return null;`
`73`	`72`	`}`
`74`	`73`	`break;`
`75`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,23 +3,22 @@ import {`
`3`	`3`	`} from "../errors";`
`4`	`4`	`import {`
`5`	`5`	`IBaseValidatorDefinition,`
`6`		`- IValidationError,`
`7`	`6`	`IValidator,`
`8`	`7`	`} from "../interfaces";`
`9`	`8`
`10`	`9`	`export interface IMaxLengthValidatorDefinition extends IBaseValidatorDefinition {`
`11`	`10`	`maxLength: number;`
`12`	`11`	`}`
`13`	`12`
`14`		`-export class MaxLengthValidator implements IValidator<string, IMaxLengthValidatorDefinition> {`
	`13`	`+export class MaxLengthValidator implements IValidator<string \| null, IMaxLengthValidatorDefinition> {`
`15`	`14`	`constructor(public definition: IMaxLengthValidatorDefinition) {`
`16`	`15`	`this.definition.type = "max_length";`
`17`	`16`	`if (this.definition.maxLength < 0) {`
`18`	`17`	throw new NoLengthError(`the max length should be greater than, or equal to, 0`);
`19`	`18`	`}`
`20`	`19`	`}`
`21`	`20`
`22`		`- public validate(input: string): IValidationError<string, IMaxLengthValidatorDefinition> {`
	`21`	`+ public validate(input: string \| null) {`
`23`	`22`	`const err = {`
`24`	`23`	`definition: this.definition,`
`25`	`24`	`input,`
`@@ -28,7 +27,7 @@ export class MaxLengthValidator implements IValidator<string, IMaxLengthValidato`
`28`	`27`	`return err;`
`29`	`28`	`}`
`30`	`29`	`if (input.length <= this.definition.maxLength) {`
`31`		`- return;`
	`30`	`+ return null;`
`32`	`31`	`}`
`33`	`32`	`return err;`
`34`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`import {`
`2`	`2`	`IBaseValidatorDefinition,`
`3`		`- IValidationError,`
`4`	`3`	`IValidator,`
`5`	`4`	`} from "../interfaces";`
`6`	`5`
`@@ -9,12 +8,12 @@ export interface IMaximumValidatorDefinition extends IBaseValidatorDefinition {`
`9`	`8`	`exclusive: boolean;`
`10`	`9`	`}`
`11`	`10`
`12`		`-export class MaximumValidator implements IValidator<number, IMaximumValidatorDefinition> {`
	`11`	`+export class MaximumValidator implements IValidator<number \| null, IMaximumValidatorDefinition> {`
`13`	`12`	`constructor(public definition: IMaximumValidatorDefinition) {`
`14`	`13`	`this.definition.type = "maximum";`
`15`	`14`	`}`
`16`	`15`
`17`		`- public validate(input: number): IValidationError<number, IMaximumValidatorDefinition> {`
	`16`	`+ public validate(input: number \| null) {`
`18`	`17`	`const err = {`
`19`	`18`	`definition: this.definition,`
`20`	`19`	`input,`
`@@ -25,13 +24,13 @@ export class MaximumValidator implements IValidator<number, IMaximumValidatorDef`
`25`	`24`
`26`	`25`	`if (!this.definition.exclusive) {`
`27`	`26`	`if (input <= this.definition.maximum) {`
`28`		`- return;`
	`27`	`+ return null;`
`29`	`28`	`}`
`30`	`29`	`return err;`
`31`	`30`	`}`
`32`	`31`
`33`	`32`	`if (input < this.definition.maximum) {`
`34`		`- return;`
	`33`	`+ return null;`
`35`	`34`	`}`
`36`	`35`	`return err;`
`37`	`36`	`}`