fix: async rule with schema (#162)

fix: async rule with schema

Author: imbrn

src/Rule.js

@@ -51,13 +51,17 @@ class Rule {
   }
 }
 
+function pickFn(fn, variant = "simple") {
+  return typeof fn === "object" ? fn[variant] : fn;
+}
+
 function testAux(modifiers, fn) {
   if (modifiers.length) {
     const modifier = modifiers.shift();
     const nextFn = testAux(modifiers, fn);
     return modifier.perform(nextFn);
   } else {
-    return fn;
+    return pickFn(fn);
   }
 }
 
@@ -67,7 +71,7 @@ function testAsyncAux(modifiers, fn) {
     const nextFn = testAsyncAux(modifiers, fn);
     return modifier.performAsync(nextFn);
   } else {
-    return value => Promise.resolve(fn(value));
+    return value => Promise.resolve(pickFn(fn, "async")(value));
   }
 }
 

src/v8n.js

@@ -40,7 +40,10 @@ function proxyContext(context) {
 const availableModifiers = {
   not: {
     simple: fn => value => !fn(value),
-    async: fn => value => Promise.resolve(fn(value)).then(result => !result)
+    async: fn => value =>
+      Promise.resolve(fn(value))
+        .then(result => !result)
+        .catch(e => true)
   },
 
   some: {
@@ -57,7 +60,7 @@ const availableModifiers = {
       return Promise.all(
         split(value).map(item => {
           try {
-            return fn(item);
+            return fn(item).catch(e => false);
           } catch (ex) {
             return false;
           }
@@ -206,21 +209,40 @@ function isIntegerPolyfill(value) {
 }
 
 function testSchema(schema) {
-  return value => {
-    const causes = [];
-    Object.keys(schema).forEach(key => {
-      const nestedValidation = schema[key];
-      try {
-        nestedValidation.check((value || {})[key]);
-      } catch (ex) {
-        ex.target = key;
-        causes.push(ex);
+  return {
+    simple: value => {
+      const causes = [];
+      Object.keys(schema).forEach(key => {
+        const nestedValidation = schema[key];
+        try {
+          nestedValidation.check((value || {})[key]);
+        } catch (ex) {
+          ex.target = key;
+          causes.push(ex);
+        }
+      });
+      if (causes.length > 0) {
+        throw causes;
       }
-    });
-    if (causes.length > 0) {
-      throw causes;
+      return true;
+    },
+    async: value => {
+      const causes = [];
+      const nested = Object.keys(schema).map(key => {
+        const nestedValidation = schema[key];
+        return nestedValidation.testAsync((value || {})[key]).catch(ex => {
+          ex.target = key;
+          causes.push(ex);
+        });
+      });
+      return Promise.all(nested).then(values => {
+        if (causes.length > 0) {
+          throw causes;
+        }
+
+        return true;
+      });
     }
-    return true;
   };
 }
 

src/v8n.test.js

@@ -220,6 +220,26 @@ describe("execution functions", () => {
       });
     });
 
+    describe("working with schema's", () => {
+      it("should handle async rule within a schema", async () => {
+        v8n.extend({ asyncRule });
+
+        const validation = v8n().schema({
+          item: v8n()
+            .number()
+            .asyncRule([10, 17, 20])
+        });
+
+        await expect(
+          validation.testAsync({ item: "10" })
+        ).rejects.toBeDefined();
+        await expect(validation.testAsync({ item: 11 })).rejects.toBeDefined();
+        await expect(validation.testAsync({ item: 17 })).resolves.toEqual({
+          item: 17
+        });
+      });
+    });
+
     describe("the returned Promise", () => {
       it("should resolves when valid", async () => {
         const validation = v8n()