fix(n4s): make enforce chaining work

.gitignore

@@ -1,5 +1,6 @@
-packages/*/index.js
+packages/*/*.js
 packages/*/umd/
+packages/*/es/
 packages/*/cjs/
 packages/*/*.tgz
 

packages/n4s/src/n4s.ts

@@ -2,24 +2,21 @@ import throwError from 'throwError';
 import { DropFirst } from 'utilityTypes';
 
 import { isEmpty } from 'isEmpty';
-import type {
-  TRuleReturn,
-  TRuleDetailedResult,
-  TLazyRuleMethods,
-} from 'ruleReturn';
-import { baseRules, compounds, TRule, TRuleValue, TArgs } from 'runtimeRules';
+import type { TRuleDetailedResult, TLazyRuleMethods } from 'ruleReturn';
+import {
+  baseRules,
+  compounds,
+  getRule,
+  TRule,
+  TRuleValue,
+  TArgs,
+} from 'runtimeRules';
 import { transformResult } from 'transformResult';
 
-const rules: typeof baseRules &
-  Record<string, (...args: TArgs) => TRuleReturn> = {
-  ...baseRules,
-};
-
 function EnforceBase(value: TRuleValue): TEaegerRules {
   const proxy = new Proxy({} as TEaegerRules, {
-    get: (target, ruleName: string) => {
-      // @ts-ignore - this is actually fine
-      const rule = rules[ruleName] || compounds[ruleName];
+    get: (_, ruleName: string) => {
+      const rule = getRule(ruleName);
       if (rule) {
         return (...args: TArgs) => {
           const transformedResult = transformResult(
@@ -38,44 +35,42 @@ function EnforceBase(value: TRuleValue): TEaegerRules {
               throw transformedResult.message;
             }
           }
+          return proxy;
         };
       }
-
-      return target[ruleName];
     },
   });
 
   return proxy;
 }
 
 const enforce = new Proxy(EnforceBase as TEnforce, {
-  get: (target: TEnforce, key: string) => {
-    const registeredRules: Array<(value: TRuleValue) => TRuleDetailedResult> =
-      [];
+  get: (_: TEnforce, key: string) => {
+    const registeredRules: TRegisteredRules = [];
 
     if (key === 'extend') {
       return function extend(customRules: TRule) {
-        Object.assign(rules, customRules);
+        Object.assign(baseRules, customRules);
       };
     }
 
-    // @ts-ignore - this is actually fine
-    if (!rules[key] || !compounds[key]) {
-      return target[key];
+    if (!getRule(key)) {
+      return;
     }
 
+    return addRegisteredRule(key);
+
     function addRegisteredRule(ruleName: string) {
       return (...args: TArgs) => {
-        // @ts-ignore - this is actually fine
-        const rule = rules[ruleName] || compounds[ruleName];
+        const rule = getRule(ruleName);
 
         registeredRules.push((value: TRuleValue) =>
           transformResult(rule(value, ...args), ruleName, value, ...args)
         );
 
         const proxy: TEnforce = new Proxy({} as TEnforce, {
-          get: (target, key: string) => {
-            if (rules[key]) {
+          get: (_, key: string) => {
+            if (getRule(key)) {
               return addRegisteredRule(key);
             }
 
@@ -90,44 +85,41 @@ const enforce = new Proxy(EnforceBase as TEnforce, {
             }
 
             if (key === 'test') {
-              // @ts-ignore need to fix this
               return (value: TRuleValue) => proxy.run(value).pass;
             }
-
-            return target[key];
           },
         });
         return proxy;
       };
     }
-
-    return addRegisteredRule(key);
   },
 });
 
 export default enforce;
 
+type TRegisteredRules = Array<(value: TRuleValue) => TRuleDetailedResult>;
+
 type TEaegerRules = {
   [P in keyof typeof compounds]: (
     ...args: DropFirst<Parameters<typeof compounds[P]>>
   ) => TEaegerRules;
 } &
   {
-    [P in keyof typeof rules]: (
-      ...args: DropFirst<Parameters<typeof rules[P]>>
+    [P in keyof typeof baseRules]: (
+      ...args: DropFirst<Parameters<typeof baseRules[P]>>
     ) => TEaegerRules;
   };
 
 type TLazyRules = {
   [P in keyof typeof compounds]: (
-    ...args: DropFirst<Parameters<typeof compounds[P]>>
+    ...args: DropFirst<Parameters<typeof compounds[P]>> | TArgs
   ) => TLazyRules & TLazyRuleMethods;
 } &
   {
-    [P in keyof typeof rules]: (
-      ...args: DropFirst<Parameters<typeof rules[P]>>
+    [P in keyof typeof baseRules]: (
+      ...args: DropFirst<Parameters<typeof baseRules[P]>> | TArgs
     ) => TLazyRules & TLazyRuleMethods;
   };
 
 type TEnforce = typeof EnforceBase &
-  TLazyRules & { extend: (customRules: TRule) => void };
+  TLazyRules & { extend: (customRules: TRule) => void } & TLazyRuleMethods;

packages/n4s/src/runtime/runtimeRules.ts

@@ -12,4 +12,9 @@ export type TRule = Record<string, TRuleBase>;
 
 const baseRules = rules();
 
-export { baseRules, compounds };
+function getRule(ruleName: string) {
+  // @ts-ignore - this should actually be fine
+  return baseRules[ruleName] || compounds[ruleName];
+}
+
+export { baseRules, compounds, getRule };

packages/vest/types/vest.d.ts

@@ -168,34 +168,21 @@ declare const baseRules: {
   shorterThanOrEquals: typeof shorterThanOrEquals;
   startsWith: typeof startsWith;
 };
-declare const rules: typeof baseRules &
-  Record<string, (...args: TArgs) => TRuleReturn>;
 declare function EnforceBase(value: TRuleValue): TEaegerRules;
 declare const enforce: TEnforce;
 type TEaegerRules = {
-  [P in keyof typeof compounds]: (
-    ...args: DropFirst<Parameters<typeof compounds[P]>>
-  ) => TEaegerRules;
-} &
-  {
-    [P in keyof typeof rules]: (
-      ...args: DropFirst<Parameters<typeof rules[P]>>
-    ) => TEaegerRules;
-  };
+    [P in keyof typeof compounds]: (...args: DropFirst<Parameters<typeof compounds[P]>>) => TEaegerRules;
+} & {
+    [P in keyof typeof baseRules]: (...args: DropFirst<Parameters<typeof baseRules[P]>>) => TEaegerRules;
+};
 type TLazyRules = {
-  [P in keyof typeof compounds]: (
-    ...args: DropFirst<Parameters<typeof compounds[P]>>
-  ) => TLazyRules & TLazyRuleMethods;
-} &
-  {
-    [P in keyof typeof rules]: (
-      ...args: DropFirst<Parameters<typeof rules[P]>>
-    ) => TLazyRules & TLazyRuleMethods;
-  };
-type TEnforce = typeof EnforceBase &
-  TLazyRules & {
+    [P in keyof typeof compounds]: (...args: DropFirst<Parameters<typeof compounds[P]>> | TArgs) => TLazyRules & TLazyRuleMethods;
+} & {
+    [P in keyof typeof baseRules]: (...args: DropFirst<Parameters<typeof baseRules[P]>> | TArgs) => TLazyRules & TLazyRuleMethods;
+};
+type TEnforce = typeof EnforceBase & TLazyRules & {
     extend: (customRules: TRule) => void;
-  };
+} & TLazyRuleMethods;
 /**
  * Reads the testObjects list and gets full validation result from it.
  */

vx/cli.js

@@ -66,6 +66,11 @@ const { package, command, dry = false } = cli;
 if (!commands[command]) {
   throw new Error(`Command ${command} not found.`);
 }
+
+if (package) {
+  packageName.setPackageName(package);
+}
+
 // FIXME: is there a better way of doing this?
 const options = argv.slice(
   namedOptions.reduce((count, [option, increment]) => {

vx/commands/build.js

@@ -2,9 +2,9 @@ const exec = require('vx/exec');
 
 function build(packageName, { options }) {
   if (packageName) {
-    exec([`yarn workspace ${packageName} vx buildPackage`, options]);
+    exec([`yarn workspace ${packageName} vx pack`, options]);
   } else {
-    exec([`yarn workspaces run vx buildPackage`, options]);
+    exec([`yarn workspaces run vx pack`, options]);
   }
 }
 

vx/commands/buildPackage.js → vx/commands/pack.js

@@ -2,12 +2,12 @@ const buildPackage = require('../scripts/build/buildPackage');
 
 const packageName = require('vx/packageName');
 
-function build(name = packageName(), { options }) {
+function pack(name = packageName(), { options }) {
   if (!name) {
-    throw new Error('buildPackage must be called with a package name!');
+    throw new Error('pack must be called with a package name!');
   }
 
   buildPackage(name, { options });
 }
 
-module.exports = build;
+module.exports = pack;

vx/config/rollup/rollup.config.js

@@ -26,6 +26,7 @@ module.exports = () => {
   if (fs.existsSync(customConfigPath)) {
     customConfig = require(customConfigPath);
   }
+
   return cleanupConfig(
     customConfig?.(configs, {
       getInputFile,

vx/packageName.js

@@ -1,5 +1,7 @@
 module.exports = function packageName() {
-  const name = process.env.npm_package_name;
+  return process.env.VX_PACKAGE_NAME ?? process.env.npm_package_name;
+};
 
-  return name;
+module.exports.setPackageName = function (name) {
+  process.env.VX_PACKAGE_NAME = name;
 };

vx/scripts/build/buildPackage.js

@@ -1,5 +1,6 @@
 const fse = require('fs-extra');
 
+const copyDist = require('./../release/steps/copyDist');
 const writeMainTemplate = require('./writeMainTemplate');
 
 const exec = require('vx/exec');
@@ -15,6 +16,8 @@ function buildPackage(name = packageName(), { options } = {}) {
   exec([`rollup -c`, vxPath.ROLLUP_CONFIG_PATH, options]);
 
   writeMainTemplate(packageName(), vxPath.packageDist(packageName()));
+
+  copyDist();
 }
 
 module.exports = buildPackage;

vx/scripts/release/releasePackage.js

@@ -1,7 +1,6 @@
 const build = require('./../build/buildPackage');
 const genDiffData = require('./../release/genDiffData');
 const getDiff = require('./../release/github/getDiff');
-const copyDist = require('./../release/steps/copyDist');
 const publishPackage = require('./../release/steps/publishPackage');
 const setNextVersion = require('./../release/steps/setNextVersion');
 const updateChangelog = require('./../release/steps/updateChangelog');
@@ -30,8 +29,6 @@ function releasePackage(packageName) {
   updateChangelog(diffData);
 
   publishPackage(diffData);
-
-  copyDist();
 }
 
 module.exports = releasePackage;

vx/util/dryRun.js

@@ -14,7 +14,8 @@ function setDryRun(dry) {
 }
 
 function isDryRun() {
-  return !!process.env[DRY_RUN_KEY];
+  // FIXME: Check why this is sometimes gets set to a string
+  return [true, 'true'].includes(process.env[DRY_RUN_KEY]);
 }
 
 function cliOpt() {