added: [n4s] lazy evaluated enforcements (#479)

Author: ealush

config/rollup/getPlugins.js

@@ -34,7 +34,7 @@ module.exports = function ({ dev = false, format, min, libraryName, version }) {
     alias({ entries: aliases }),
     resolve(),
     commonjs({
-      include: /node_modules\/(anyone|n4s)/,
+      include: /node_modules\/(anyone|n4s|wait)/,
     }),
     babel({
       configFile: filePaths.BABEL_CONFIG_PATH,

package.json

@@ -34,7 +34,6 @@
     "@babel/plugin-transform-runtime": "^7.12.1",
     "@babel/preset-env": "^7.12.1",
     "@babel/register": "^7.12.1",
-    "@lets/wait": "^2.0.2",
     "@rollup/plugin-alias": "^3.1.1",
     "@rollup/plugin-babel": "^5.2.1",
     "@rollup/plugin-commonjs": "^16.0.0",
@@ -64,6 +63,7 @@
     "rollup-plugin-terser": "^7.0.2",
     "semver": "^7.3.2",
     "typescript": "^4.0.5",
-    "validator": "^13.1.17"
+    "validator": "^13.1.17",
+    "wait": "^0.4.1"
   }
 }

packages/n4s/src/enforce/__tests__/enforce.test.js

@@ -80,6 +80,45 @@ const suite = ({ withProxy, requirePath }) =>
       });
     });
 
+    describe('lazy enforcements', () => {
+      it('Should expose all rules on top of the enforce function', () => {
+        allRules.forEach(rule => expect(typeof enforce[rule]).toBe('function'));
+
+        expect(enforce.isAbc).toBeUndefined();
+        enforce.extend({ isAbc: v => v === 'abc' });
+        expect(typeof enforce.isAbc).toBe('function');
+      });
+
+      test('Each rule returns a function', () => {
+        allRules.forEach(rule =>
+          expect(typeof enforce[rule]()).toBe('function')
+        );
+      });
+
+      test('Returned function returns a boolean value', () => {
+        expect(enforce.isArray()([])).toBe(true);
+        expect(enforce.isNumber()('not_a_number')).toBe(false);
+      });
+
+      it("Should use the second function's argument as the enforce value, and the first function's arguments as the ...rest", () => {
+        expect(enforce.isEmpty()([])).toBe(true);
+        expect(enforce.isEmpty()([1, 2, 3])).toBe(false);
+        expect(enforce.isNumeric()('555')).toBe(true);
+        expect(enforce.greaterThan(10)(20)).toBe(true);
+        expect(enforce.greaterThan(10)(4)).toBe(false);
+
+        const fn = jest.fn(() => true);
+
+        enforce.extend({
+          getArgs: fn,
+        });
+
+        enforce.getArgs(2, 3, 4, 5, 6, 7)(1);
+        // One should be first
+        expect(fn).toHaveBeenCalledWith(1, 2, 3, 4, 5, 6, 7);
+      });
+    });
+
     it('Should throw errors on failing enforces', () => {
       const isNumber = () => enforce('a').isNumber(true);
       expect(isNumber).toThrow(Error);

packages/n4s/src/enforce/enforce.js

@@ -7,12 +7,24 @@ const rulesObject = rules();
 
 let enforce, rulesList;
 
+const bindLazyRule = ruleName => (...args) => value =>
+  rulesObject[ruleName](value, ...args);
+
+const bindLazyRules = rules =>
+  rules.reduce(
+    (enforce, ruleName) =>
+      Object.assign(enforce, {
+        [ruleName]: bindLazyRule(ruleName),
+      }),
+    enforce
+  );
+
 if (proxySupported()) {
-  enforce = value => {
+  const enforceMain = value => {
     const proxy = new Proxy(rulesObject, {
       get: (rules, fnName) => {
         if (!isRule(rules, fnName)) {
-          return;
+          return enforce[fnName];
         }
 
         return (...args) => {
@@ -23,29 +35,43 @@ if (proxySupported()) {
     });
     return proxy;
   };
+
+  // This is for lazy enforcement: enforce.isArray()([]) // true
+  enforce = new Proxy(enforceMain, {
+    get: (enforce, fnName) => {
+      if (!isRule(rulesObject, fnName)) {
+        return enforce[fnName];
+      }
+
+      return bindLazyRule(fnName);
+    },
+  });
 } else {
   rulesList = Object.keys(rulesObject);
 
+  // This is for lazy enforcement: enforce.isArray()([]) // true
   enforce = value =>
-    rulesList.reduce(
-      (allRules, fnName) =>
-        Object.assign(allRules, {
-          ...(isRule(rulesObject, fnName) && {
-            [fnName]: (...args) => {
-              runner(rulesObject[fnName], value, ...args);
-              return allRules;
-            },
-          }),
-        }),
-      {}
-    );
+    rulesList.reduce((allRules, fnName) => {
+      if (!isRule(rulesObject, fnName)) {
+        return enforce[fnName];
+      }
+      return Object.assign(allRules, {
+        [fnName]: (...args) => {
+          runner(rulesObject[fnName], value, ...args);
+          return allRules;
+        },
+      });
+    }, {});
+
+  bindLazyRules(rulesList);
 }
 
 enforce.extend = customRules => {
   Object.assign(rulesObject, customRules);
 
   if (!proxySupported()) {
     rulesList = Object.keys(rulesObject);
+    bindLazyRules(Object.keys(customRules));
   }
 
   return enforce;

packages/n4s/src/enforce/enforceRunner.js

@@ -1,4 +1,3 @@
-import isFunction from 'isFunction';
 import { transformResult } from 'transformResult';
 
 /**
@@ -10,10 +9,6 @@ import { transformResult } from 'transformResult';
  * @throws
  */
 function runner(rule, value, ...args) {
-  if (!isFunction(rule)) {
-    return;
-  }
-
   const ruleResult = rule(value, ...args);
   const result = transformResult(ruleResult, { rule, value });
   if (!result.pass) {

packages/n4s/src/lib/isRule.js

@@ -1,18 +1,7 @@
 import isFunction from 'isFunction';
-import throwError from 'throwError';
 
 const isRule = (rulesObject, name) => {
-  const ruleExists =
-    Object.prototype.hasOwnProperty.call(rulesObject, name) &&
-    isFunction(rulesObject[name]);
-
-  if (!ruleExists) {
-    throwError(
-      `Rule "${name}" was not found in rules object. Make sure you typed it correctly.`
-    );
-  }
-
-  return ruleExists;
+  return rulesObject.hasOwnProperty(name) && isFunction(rulesObject[name]);
 };
 
 export default isRule;

packages/n4s/src/lib/transformResult.js

@@ -38,17 +38,15 @@ export function transformResult(result, { rule, value }) {
 
   // if result is boolean
   if (!!result === result) {
-    return { ...defaultResult, pass: result };
+    return (defaultResult.pass = result), defaultResult;
   } else {
-    const formattedResult = {
-      pass: result.pass,
-    };
+    defaultResult.pass = result.pass;
     if (result.message) {
-      formattedResult.message = formatResultMessage(
+      defaultResult.message = formatResultMessage(
         rule,
         isFunction(result.message) ? result.message() : result.message
       );
     }
-    return { ...defaultResult, ...formattedResult };
+    return defaultResult;
   }
 }

packages/vest/src/core/test/__tests__/memo.test.js

@@ -1,5 +1,5 @@
-import wait from '@lets/wait';
 import enforce from 'n4s';
+import wait from 'wait';
 
 import vest from '../../..';
 

packages/vest/src/index.js

@@ -1,6 +1,5 @@
-import enforce from 'n4s';
-
 import create from 'createSuite';
+import enforce from 'enforce';
 import { only, skip, warn, group } from 'hooks';
 import test from 'test';
 

packages/vest/src/index.mjs

@@ -1,6 +1,5 @@
-import enforce from 'n4s';
-
 import create from 'createSuite';
+import enforce from 'enforce';
 import { only, skip, warn, group } from 'hooks';
 import test from 'test';