feat: make validating async

Running validate now will return a promise with the validation result. This allows us to support
constraints that return promises.

BREAKING CHANGE: validate() now returns a promise.

Author: jamesfer

package.json

@@ -74,6 +74,8 @@
   "dependencies": {
     "date-fns": "^2.0.0-0",
     "lodash-es": "^4.17.11",
+    "p-map": "^2.0.0",
+    "p-map-series": "^1.0.0",
     "tslib": "^1.8.3"
   },
   "devDependencies": {
@@ -83,6 +85,7 @@
     "@semantic-release/git": "^7.0.4",
     "@types/jest": "^23.3.2",
     "@types/lodash-es": "^4.17.1",
+    "@types/p-map-series": "^1.0.1",
     "babel-plugin-lodash": "^3.3.4",
     "commitizen": "^2.10.1",
     "jest": "^23.6.0",

rollup.config.js

@@ -32,7 +32,15 @@ export default ({ 'config-visualize': visualize }) => {
       plugins: [
         resolve(),
         commonjs(),
-        typescript({ target, tsconfig: 'tsconfig.build.json' }),
+        typescript({
+          target,
+          tsconfig: 'tsconfig.build.json',
+          include: [
+            'src/**',
+            'node_modules/lodash-es',
+            'node_modules/p-*/**',
+          ],
+        }),
         babel({ extensions: ['.ts'] }),
       ].concat(
         minify ? uglify() : [],

src/groups/has-elements.spec.ts

@@ -1,62 +1,69 @@
 import { maxLength, string } from '../rules';
 import { validate } from '../validate';
 import { hasElements } from './has-elements';
+import pMapSeries = require('p-map-series');
 
 const rules = [string(), maxLength(10)];
 
+function validateEach(values: any, constraints = rules) {
+  return pMapSeries(values, async value => (await validate(value, constraints)).all());
+}
+
 describe('hasElements', () => {
-  it('should pass null and undefined', () => {
-    expect(validate(null, hasElements(rules)).passed()).toBe(true);
-    expect(validate(undefined, hasElements(rules)).passed()).toBe(true);
+  it('should pass null and undefined', async () => {
+    expect((await validate(null, hasElements(rules))).passed()).toBe(true);
+    expect((await validate(undefined, hasElements(rules))).passed()).toBe(true);
   });
 
-  it('should an array of results', () => {
+  it('should return an array of results', async () => {
     const values = [1, 2];
-    const messages = validate(values, hasElements(rules)).all();
-    expect(messages).toEqual(values.map(value => validate(value, rules).all()));
+    const result = await validate(values, hasElements(rules));
+    const expectedMessages = await validateEach(values);
+    expect(result.all()).toEqual(expectedMessages);
   });
 
-  it('should validate each object individually', () => {
+  it('should validate each object individually', async () => {
     const values = ['hello', 5, 'world'];
-    const messages = validate(values, hasElements(rules)).all();
-    expect(messages).toEqual(values.map(value => validate(value, rules).all()));
+    const result = await validate(values, hasElements(rules));
+    const expectedMessages = await validateEach(values);
+    expect(result.all()).toEqual(expectedMessages);
   });
 
-  it('should work on all array like objects', () => {
+  it('should work on all array like objects', async () => {
     const string = 'hello';
-    let messages = validate(string, hasElements(rules)).all();
-    expect(messages).toEqual(Array.from(string).map(value => validate(value, rules).all()));
+    let result = await validate(string, hasElements(rules));
+    expect(result.all()).toEqual(await validateEach(Array.from(string)));
 
     const object = { 1: 'h', 2: 'i', length: 2 };
-    messages = validate(object, hasElements(rules)).all();
-    expect(messages).toEqual(Array.from(object).map(value => validate(value, rules).all()));
+    result = await validate(object, hasElements(rules));
+    expect(result.all()).toEqual(await validateEach(Array.from(object)));
   });
 
-  it('should correctly pass the key option', () => {
+  it('should correctly pass the key option', async () => {
     const constraint = jest.fn(() => undefined);
     const parent = ['a', 'b', 'c'];
-    validate(parent, hasElements([constraint]));
+    await validate(parent, hasElements([constraint]));
     parent.forEach((value, index) => {
       const options = expect.objectContaining({ key: `${index}` });
       expect(constraint).nthCalledWith(index + 1, value, options);
     });
   });
 
-  it('should correctly pass the key path option', () => {
+  it('should correctly pass the key path option', async () => {
     const constraint = jest.fn(() => undefined);
     const parent = ['a', 'b', 'c'];
-    validate(parent, hasElements([constraint]));
+    await validate(parent, hasElements([constraint]));
     parent.forEach((value, index) => {
       const options = expect.objectContaining({ keyPath: [`${index}`] });
       expect(constraint).nthCalledWith(index + 1, value, options);
     });
   });
 
-  it('should correctly pass the key path option when nested', () => {
+  it('should correctly pass the key path option when nested', async () => {
     const constraint = jest.fn(() => undefined);
     const child = ['a', 'b', 'c'];
     const parent = [child, child, child];
-    validate(parent, hasElements(hasElements([constraint])));
+    await validate(parent, hasElements(hasElements([constraint])));
     parent.forEach((_, parentIndex) => {
       child.forEach((value, childIndex) => {
         const index = parentIndex * child.length + childIndex;
@@ -66,10 +73,10 @@ describe('hasElements', () => {
     });
   });
 
-  it('should correctly pass the parent option', () => {
+  it('should correctly pass the parent option', async () => {
     const constraint = jest.fn(() => undefined);
     const parent = ['a', 'b', 'c'];
-    validate(parent, hasElements([constraint]));
+    await validate(parent, hasElements([constraint]));
     parent.forEach((value, index) => {
       const options = expect.objectContaining({ parent });
       expect(constraint).nthCalledWith(index + 1, value, options);

src/groups/has-elements.ts

@@ -1,27 +1,25 @@
+import pMap from 'p-map';
+import { isArrayLike } from 'lodash-es';
 import { InternalConstraint, GroupConstraint, ConstraintOptions } from '../make-constraint';
 import { runConstraints } from '../validate';
-import { isArrayLike } from 'lodash-es';
 
 export function hasElements<T = string[]>(
   constraints: InternalConstraint[] | GroupConstraint<T>,
 ): GroupConstraint<(T | undefined)[]> {
-  return (value, options) => {
-    const childOptions: ConstraintOptions = {
-      ...options,
-      parent: value,
-    };
-    if (isArrayLike(value)) {
-      // Need to use a normal for loop to support all array like objects
-      const messages: (T | undefined)[] = Array(value.length);
-      for (let i = 0; i < messages.length; i += 1) {
-        const key = `${i}`;
-        messages[i] = runConstraints(value[i], constraints, {
-          ...childOptions,
-          key,
-          keyPath: [...childOptions.keyPath, key],
-        });
-      }
-      return messages;
+  return (values, options) => {
+    if (!isArrayLike(values)) {
+      return undefined;
     }
+
+    const childOptions: ConstraintOptions = { ...options, parent: values };
+    // Need to use Array.from to support all array like objects
+    return pMap(Array.from(values), (value, index) => {
+      const key = index.toString();
+      return runConstraints(value, constraints, {
+        ...childOptions,
+        key,
+        keyPath: [...childOptions.keyPath, key],
+      });
+    });
   };
 }

src/groups/has-properties.spec.ts

@@ -1,37 +1,37 @@
 import { validate } from '../validate';
 import { hasProperties } from './has-properties';
 import { greaterThan, required, string } from '../rules';
-import { assertType, Dictionary, returns } from '../type-assertions';
+import { assertType, Dictionary, returns } from '../utils';
 import { mapValues } from 'lodash-es';
 
 describe('object', () => {
   const requiredString = [required(), string()];
 
-  it('should return messages in order', () => {
+  it('should return messages in order', async () => {
     const test = { firstName: 1 };
     const rules = { firstName: [string(), greaterThan(2)] };
-    const result = validate(test, hasProperties(rules));
+    const result = await validate(test, hasProperties(rules));
     const messages = result.flattened();
     expect(messages).toHaveLength(2);
     expect(messages[0]).toMatch(/must be a string/);
     expect(messages[1]).toMatch(/must be greater than/);
   });
 
-  it('should not return properties that have passed validation', () => {
+  it('should not return properties that have passed validation', async () => {
     const test = { firstName: 'tim' };
     const rules = { firstName: requiredString, lastName: requiredString };
-    const result = validate(test, hasProperties(rules)).all();
+    const result = (await validate(test, hasProperties(rules))).all();
     if (result) {
       expect(result.firstName).toBe(undefined);
       expect(result.hasOwnProperty('firstName')).toBe(false);
       expect('firstName' in result).toBe(false);
     }
   });
 
-  it('should retain the shape of the input in the message object', () => {
+  it('should retain the shape of the input in the message object', async () => {
     const test = { firstName: 'tim' };
     const rules = { firstName: requiredString, lastName: requiredString };
-    const result = validate(test, hasProperties(rules)).all();
+    const result = (await validate(test, hasProperties(rules))).all();
     if (result) {
       assertType<string[] | undefined>(result.firstName);
       assertType<typeof result.firstName>(returns<string[] | undefined>());
@@ -41,11 +41,11 @@ describe('object', () => {
     }
   });
 
-  it('should retain the shape of child objects of the input in the message object', () => {
+  it('should retain the shape of child objects of the input in the message object', async () => {
     const test = { parent: { firstName: 'tim' } };
-    const result = validate(test, hasProperties({
+    const result = (await validate(test, hasProperties({
       parent: hasProperties({ firstName: requiredString }),
-    })).all();
+    }))).all();
 
     if (result) {
       assertType<{ parent?: { firstName?: string[] } }>(result);
@@ -63,8 +63,8 @@ describe('object', () => {
     }
   });
 
-  it('should work', () => {
-    const result = validate(
+  it('should work', async () => {
+    const result = await validate(
       { firstName: 'tim' },
       hasProperties({
         firstName: [required()],
@@ -78,32 +78,32 @@ describe('object', () => {
     expect(messages[0]).toMatch(/required/);
   });
 
-  it('should correctly pass the key option', () => {
+  it('should correctly pass the key option', async () => {
     const constraint = jest.fn(() => undefined);
     const parent: Dictionary<number> = { a: 1, b: 2 };
-    validate(parent, hasProperties(mapValues(parent, () => constraint)));
+    await validate(parent, hasProperties(mapValues(parent, () => constraint)));
     Object.keys(parent).forEach((key, index) => {
       const options = expect.objectContaining({ key });
       expect(constraint).nthCalledWith(index + 1, parent[key], options);
     });
   });
 
-  it('should correctly pass the key path option', () => {
+  it('should correctly pass the key path option', async () => {
     const constraint = jest.fn(() => undefined);
     const parent: Dictionary<number> = { a: 1, b: 2 };
-    validate(parent, hasProperties(mapValues(parent, () => constraint)));
+    await validate(parent, hasProperties(mapValues(parent, () => constraint)));
     Object.keys(parent).forEach((key, index) => {
       const options = expect.objectContaining({ keyPath: [key] });
       expect(constraint).nthCalledWith(index + 1, parent[key], options);
     });
   });
 
-  it('should correctly pass the key path option when nested', () => {
+  it('should correctly pass the key path option when nested', async () => {
     const constraint = jest.fn(() => undefined);
     const child: Dictionary<number> = { a: 1, b: 2 };
     const parent: Dictionary<Dictionary<number>> = { c: child, d: child };
     const childConstraints = hasProperties(mapValues(child, () => constraint));
-    validate(parent, hasProperties(mapValues(parent, () => childConstraints)));
+    await validate(parent, hasProperties(mapValues(parent, () => childConstraints)));
     Object.keys(parent).forEach((parentKey, parentIndex) => {
       Object.keys(child).forEach((childKey, childIndex) => {
         const index = parentIndex * Object.keys(child).length + childIndex;
@@ -113,10 +113,10 @@ describe('object', () => {
     });
   });
 
-  it('should correctly pass the parent option', () => {
+  it('should correctly pass the parent option', async () => {
     const constraint = jest.fn(() => undefined);
     const parent: Dictionary<number> = { a: 1, b: 2 };
-    validate(parent, hasProperties(mapValues(parent, () => constraint)));
+    await validate(parent, hasProperties(mapValues(parent, () => constraint)));
     Object.keys(parent).forEach((key, index) => {
       const options = expect.objectContaining({ parent });
       expect(constraint).nthCalledWith(index + 1, parent[key], options);

src/groups/has-properties.ts

@@ -1,57 +1,46 @@
+import pMap from 'p-map';
+import { isUndefined, omitBy, zipObject } from 'lodash-es';
 import { ObjectMessageMap, ObjectValidatorMap, runConstraints } from '../validate';
-import { ConstraintOptions } from '../make-constraint';
-import { Dictionary } from '../type-assertions';
+import { ConstraintOptions, GroupConstraint } from '../make-constraint';
+import { Dictionary } from '../utils';
 
-function runPropertyConstraints<T extends ObjectValidatorMap<any>>(
-  resultMap: ObjectMessageMap<T>,
-  name: string,
+function runPropertyConstraint<T extends ObjectValidatorMap<any>>(
   value: any,
-  constraints: any,
+  constraints: T,
   options: ConstraintOptions,
-): boolean {
-  const result = runConstraints(value, constraints, options);
-  if (result !== undefined) {
-    resultMap[name] = result as any;
-    return false;
-  }
-  return true;
+): (key: string) => Promise<any> {
+  return (key) => {
+    const propertyOptions = {
+      ...options,
+      key,
+      keyPath: [...options.keyPath, key],
+      parent: value,
+    };
+    return runConstraints(value[key], constraints[key], propertyOptions);
+  };
 }
 
 function runObjectConstraints<T extends ObjectValidatorMap<any>>(
-  constraints: T,
   value: Dictionary<any>,
+  constraints: T,
   options: ConstraintOptions,
-): ObjectMessageMap<T> | undefined {
-  let allConstraintsPassed = true;
-  const resultMap = Object.keys(constraints).reduce<ObjectMessageMap<T>>(
-    (resultMap, key) => {
-      const propertyOptions = {
-        ...options,
-        key,
-        keyPath: [...options.keyPath, key],
-        parent: value,
-      };
-
-      const result = runConstraints(value[key], constraints[key], propertyOptions);
-      if (result !== undefined) {
-        resultMap[key] = result as any;
-        allConstraintsPassed = false;
-      }
-
-      return resultMap;
-    },
-    {},
-  );
-  return allConstraintsPassed ? undefined : resultMap;
+): Promise<ObjectMessageMap<T> | undefined> {
+  const keys = Object.keys(constraints);
+  return pMap(keys, runPropertyConstraint(value, constraints, options))
+    .then(results => (
+      results.every(isUndefined)
+        ? undefined
+        : omitBy(zipObject(keys, results), isUndefined) as ObjectMessageMap<T>
+    ));
 }
 
 export function hasProperties<T extends ObjectValidatorMap<any>>(
   constraints: T,
-): (...args: any[]) => ObjectMessageMap<T> | undefined {
-  return (value: any, options: ConstraintOptions): ObjectMessageMap<T> | undefined => {
+): GroupConstraint<ObjectMessageMap<T> | undefined> {
+  return (value: any, options: ConstraintOptions) => {
     if (value === null || typeof value !== 'object') {
-      return undefined;
+      return Promise.resolve(undefined);
     }
-    return runObjectConstraints(constraints, value, options);
+    return runObjectConstraints(value, constraints, options);
   };
 }