feat: includes flow types + fixes sanitazing

Author: Rodrigo Solis

README.md

@@ -8,7 +8,7 @@ $ npm i proxy-validator
 ```
 
 ### Usage
-The API is fairly simple. Create a validator by providing a validator schema and/or a sanitizing schema.
+The API is fairly simple. Create a validator by providing a validation schema and/or a sanitizing schema.
 ```js
 import ProxyValidator from 'proxy-validator';
 
@@ -18,7 +18,7 @@ const validators = {
   name: {
     // The key corresponds to a validator function.
     isLength: {
-      // The body can be either an object, containing validating options and errorMessage...
+      // The value can be either an object, containing options and an errorMessage...
       options: {
         min: 6
       },
@@ -37,12 +37,16 @@ const validators = {
 };
 
 const sanitizers = {
+  // As with the validation, the sanitizing schema is formed by a a key/value pair.
   name: {
-    trim: ' '
+    // The key corresponds with the sanitizing function
+    trim: true // and the value can be either boolean (use defaults)
   },
   email: {
     normalizeEmail: {
-      all_lowercase: true
+      options: { // ...or a config options object.
+        all_lowercase: true
+      }
     }
   }
 };

src/error.js

@@ -1,5 +1,7 @@
+// @flow
+import type { ValidationErrors } from './types';
 
-function ValidationError(errors) {
+function ValidationError(errors: ValidationErrors) {
   this.name = 'ValidationError';
   this.message = JSON.stringify(errors, null, '  ');
   this.stack = new Error().stack;

src/index.js

@@ -1,3 +1,43 @@
 import ProxyValidator from './proxy';
 
+const validators = {
+  // Define a set of rules to apply for each prop, each rule is formed by a key and a value.
+  name: {
+    // The key corresponds to a validator function.
+    isLength: {
+      // The value can be either an object, containing options and an errorMessage...
+      options: {
+        min: 6
+      },
+      errorMessage: 'Minimum length 6 characters.'
+    },
+    // ...or a boolean, in which case the message will be the default one.
+    isUppercase: true
+  },
+  mobile: {
+    isMobilePhone: {
+      options: 'en-GB',
+      errorMessage: 'Invalid mobile number.'
+    },
+    isAlphanumeric: true
+  }
+};
+const sanitizers = {
+  // As with the validation, the sanitizing schema is formed by a a key/value pair.
+  name: {
+    // The key corresponds with the sanitizing function
+    trim: true // and the value can be either boolean (use defaults)
+  },
+  email: {
+    normalizeEmail: {
+      options: { // ...or a config options object.
+        all_lowercase: true
+      }
+    }
+  }
+};
+const ContactValidator = ProxyValidator(validators, sanitizers);
+
+window.contactTest = ContactValidator();
+
 export default ProxyValidator;

src/proxy.js

@@ -1,21 +1,23 @@
+// @flow
 /* eslint no-param-reassign: 0 */
 import ValidationError from './error';
 import { checkRules, applySanitizers } from './validation';
+import type { ProxyFactory } from './types';
 
-export default function ProxyValidator(schema, sanitizers) {
+export default function ProxyValidator(schema: Object, sanitizersSchema: Object): ProxyFactory {
   const handler = {
-    set(object, prop, value) {
+    set(object: Object, prop: string, value: string): boolean {
       const { [prop]: rules } = schema;
       const { success, errors } = checkRules(rules, value);
       if (success) {
-        const { [prop]: transforms } = sanitizers;
-        object[prop] = applySanitizers(transforms, value);
+        const { [prop]: sanitizers } = sanitizersSchema;
+        object[prop] = applySanitizers(sanitizers, value);
         return success;
       }
-      throw new ValidationError(errors);
+      throw new ValidationError({ [prop]: errors });
     }
   };
-  return function Proxied() {
+  return function Proxied(): Object {
     const target = {};
     return new Proxy(target, handler);
   };

src/types.js

@@ -0,0 +1,25 @@
+// @flow
+
+export type ProxyFactory = (void) => Proxy<Object>
+
+export type ValidationErrors = {
+  [string]: {
+    value: string,
+    errorMessage: string
+  }
+};
+
+export type ValidationRule = {
+  options: ?mixed,
+  errorMessage: string
+};
+export type ValidationRules = {
+  [string]: boolean | ValidationRule
+};
+
+export type SanitizingRule = {
+  options: ?mixed
+};
+export type SanitizingRules = {
+  [string]: boolean | SanitizingRule
+};

src/validation.js

@@ -1,27 +1,32 @@
+// @flow
+// $FlowFixMe
 import validator from 'validator';
+import type { ValidationRules, SanitizingRules } from './types';
 
 const GENERIC_ERROR_MESSAGE = 'Invalid input';
 
-export function checkRules(rules = {}, value) {
+export function checkRules(rules: ValidationRules = {}, value: string) {
   const errors = [];
   let success = true;
   Object.keys(rules)
     .forEach((rule) => {
       const validatorFn = validator[rule];
       const config = rules[rule];
-      const { options, errorMessage = GENERIC_ERROR_MESSAGE } = config;
+      const options = (typeof config !== 'boolean') && config.options;
+      const errorMessage = (typeof config !== 'boolean') ? config.errorMessage : GENERIC_ERROR_MESSAGE;
       success = validatorFn(value, options);
       if (!success) errors.push({ errorMessage, value });
     });
 
   return { success, errors };
 }
 
-export function applySanitizers(sanitizers = {}, value) {
+export function applySanitizers(sanitizers: SanitizingRules = {}, value: mixed): mixed {
   return Object.keys(sanitizers)
     .reduce((result, sanitizer) => {
       const sanitizerFn = validator[sanitizer];
-      const options = sanitizers[sanitizer];
+      const config = sanitizers[sanitizer];
+      const options = (typeof config !== 'boolean') && config.options;
       return sanitizerFn(result, options);
     }, value) || value;
 }