patch: use invariant utility

Author: ealush

packages/context/src/context.ts

@@ -1,7 +1,7 @@
 import assign from 'assign';
 import defaultTo from 'defaultTo';
+import invariant from 'invariant';
 import optionalFunctionValue from 'optionalFunctionValue';
-import throwError from 'throwError';
 
 // eslint-disable-next-line max-lines-per-function
 export function createContext<T extends Record<string, unknown>>(
@@ -22,12 +22,11 @@ export function createContext<T extends Record<string, unknown>>(
   };
 
   function useX(errorMessage?: string): T {
-    return (
-      (storage.ctx as T) ??
-      throwError(
-        defaultTo(errorMessage, 'Context was used after it was closed')
-      )
+    invariant(
+      storage.ctx,
+      defaultTo(errorMessage, 'Context was used after it was closed')
     );
+    return storage.ctx as T;
   }
 
   function run<R>(ctxRef: Partial<T>, fn: (context: T) => R): R {

packages/n4s/src/exports/compose.ts

@@ -1,9 +1,8 @@
+import invariant from 'invariant';
 import mapFirst from 'mapFirst';
-import throwError from 'throwError';
+import { ctx } from 'n4s';
 
 import type { TComposeResult, TLazyRuleRunners } from 'genEnforceLazy';
-import { isEmpty } from 'isEmpty';
-import { ctx } from 'n4s';
 import { defaultToPassing, TRuleDetailedResult } from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
@@ -16,14 +15,7 @@ export default function compose(
     (value: any) => {
       const res = run(value);
 
-      if (!res.pass) {
-        if (isEmpty(res.message)) {
-          throwError();
-        } else {
-          // Explicitly throw a string so that vest.test can pick it up as the validation error message
-          throw res.message;
-        }
-      }
+      invariant(res.pass, new String(res.message));
     },
     {
       run,

packages/n4s/src/lib/transformResult.ts

@@ -1,6 +1,6 @@
+import invariant from 'invariant';
 import { isBoolean } from 'isBooleanValue';
 import optionalFunctionValue from 'optionalFunctionValue';
-import throwError from 'throwError';
 
 import ruleReturn, { TRuleReturn, TRuleDetailedResult } from 'ruleReturn';
 import type { TRuleValue, TArgs } from 'runtimeRules';
@@ -29,9 +29,8 @@ export function transformResult(
 
 function validateResult(result: TRuleReturn): void {
   // if result is boolean, or if result.pass is boolean
-  if (isBoolean(result) || (result && isBoolean(result.pass))) {
-    return;
-  }
-
-  throwError('Incorrect return value for rule: ' + JSON.stringify(result));
+  invariant(
+    isBoolean(result) || (result && isBoolean(result.pass)),
+    'Incorrect return value for rule: ' + JSON.stringify(result)
+  );
 }

packages/n4s/src/runtime/enforceEager.ts

@@ -1,4 +1,4 @@
-import throwError from 'throwError';
+import invariant from 'invariant';
 
 import eachEnforceRule from 'eachEnforceRule';
 import { ctx } from 'enforceContext';
@@ -45,16 +45,13 @@ export default function enforceEager(value: TRuleValue): IRules {
         ...args
       );
 
-      if (!transformedResult.pass) {
-        if (isEmpty(transformedResult.message)) {
-          throwError(
-            `enforce/${ruleName} failed with ${JSON.stringify(value)}`
-          );
-        } else {
-          // Explicitly throw a string so that vest.test can pick it up as the validation error message
-          throw transformedResult.message;
-        }
-      }
+      invariant(
+        transformedResult.pass,
+        isEmpty(transformedResult.message)
+          ? `enforce/${ruleName} failed with ${JSON.stringify(value)}`
+          : new String(transformedResult.message)
+      );
+
       return target;
     };
   }

packages/shared/src/__tests__/throwError.test.ts

@@ -0,0 +1,19 @@
+import optionalFunctionValue from 'optionalFunctionValue';
+import { TStringable } from 'utilityTypes';
+
+export default function invariant(
+  condition: any,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  message?: String | TStringable
+): asserts condition {
+  if (condition) {
+    return;
+  }
+
+  // If message is a string object (rather than string literal)
+  // Throw the value directly as a string
+  // Alternatively, throw an error with the message
+  throw message instanceof String
+    ? message.valueOf()
+    : new Error(message ? optionalFunctionValue(message) : message);
+}

packages/shared/src/invariant.ts

@@ -1,22 +1,5 @@
-import defaultTo from 'defaultTo';
-
-/**
- * Throws a timed out error.
- */
-export default function throwError(
-  devMessage?: string,
-  productionMessage?: string
-): never {
-  throw new Error(
-    __DEV__ ? devMessage : defaultTo(productionMessage, devMessage)
-  );
-}
-
-export function throwErrorDeferred(
-  devMessage?: string,
-  productionMessage?: string
-): void {
+export function deferThrow(message?: string): void {
   setTimeout(() => {
-    throwError(devMessage, productionMessage);
+    throw new Error(message);
   }, 0);
 }

packages/shared/src/throwError.ts

@@ -5,12 +5,12 @@ import { IsolateTypes } from 'IsolateTypes';
 describe('isolate', () => {
   let firstRun = true;
   let vest, isolate, skipWhen, dummyTest;
-  let throwErrorDeferred;
+  let deferThrow;
 
   beforeEach(() => {
     firstRun = true;
     const mock = mockThrowError();
-    throwErrorDeferred = mock.throwErrorDeferred;
+    deferThrow = mock.deferThrow;
     vest = mock.vest;
     skipWhen = vest.skipWhen;
     isolate = require('isolate').isolate;
@@ -240,10 +240,10 @@ describe('isolate', () => {
         });
 
         suite();
-        expect(throwErrorDeferred).toHaveBeenCalledTimes(0);
+        expect(deferThrow).toHaveBeenCalledTimes(0);
         suite();
-        expect(throwErrorDeferred).toHaveBeenCalledTimes(1);
-        expect(throwErrorDeferred).toHaveBeenCalledWith(
+        expect(deferThrow).toHaveBeenCalledTimes(1);
+        expect(deferThrow).toHaveBeenCalledWith(
           expect.stringContaining(
             'Vest Critical Error: Tests called in different order than previous run'
           )
@@ -258,9 +258,9 @@ describe('isolate', () => {
         });
 
         suite();
-        expect(throwErrorDeferred).toHaveBeenCalledTimes(0);
+        expect(deferThrow).toHaveBeenCalledTimes(0);
         suite();
-        expect(throwErrorDeferred).toHaveBeenCalledTimes(0);
+        expect(deferThrow).toHaveBeenCalledTimes(0);
       });
     });
   });

packages/vest/src/__tests__/isolate.test.ts

@@ -1,5 +1,5 @@
+import invariant from 'invariant';
 import isFunction from 'isFunction';
-import throwError from 'throwError';
 
 import { IsolateTypes } from 'IsolateTypes';
 import { isolate } from 'isolate';
@@ -21,9 +21,7 @@ export default function each<T>(
   list: T[],
   callback: (arg: T, index: number) => void
 ): void {
-  if (!isFunction(callback)) {
-    throwError('each callback must be a function');
-  }
+  invariant(isFunction(callback), 'each callback must be a function');
 
   isolate({ type: IsolateTypes.EACH }, () => {
     list.forEach((arg, index) => {

packages/vest/src/core/isolate/isolates/each.ts

@@ -1,6 +1,6 @@
+import invariant from 'invariant';
 import isFunction from 'isFunction';
 import { isStringValue } from 'isStringValue';
-import throwError from 'throwError';
 
 import { IsolateTypes } from 'IsolateTypes';
 import context from 'ctx';
@@ -16,20 +16,16 @@ import { isolate } from 'isolate';
  * });
  */
 export default function group(groupName: string, tests: () => void): void {
-  if (!isStringValue(groupName)) {
-    throwGroupError('name must be a string');
-  }
+  invariant(isStringValue(groupName), groupErrorMsg('name must be a string'));
 
-  if (!isFunction(tests)) {
-    throwGroupError('callback must be a function');
-  }
+  invariant(isFunction(tests), groupErrorMsg('callback must be a function'));
 
   // Running with the context applied
   isolate({ type: IsolateTypes.GROUP }, () => {
     context.run({ groupName }, tests);
   });
 }
 
-function throwGroupError(error: string) {
-  throwError(`Wrong arguments passed to group. Group ${error}.`);
+function groupErrorMsg(error: string) {
+  return `Wrong arguments passed to group. Group ${error}.`;
 }

packages/vest/src/core/isolate/isolates/group.ts

@@ -1,7 +1,7 @@
 import assign from 'assign';
 import genId from 'genId';
+import invariant from 'invariant';
 import isFunction from 'isFunction';
-import throwError from 'throwError';
 import { createState } from 'vast';
 
 import { IsolateTypes } from 'IsolateTypes';
@@ -47,9 +47,10 @@ function create<T extends CB>(
 ): SuiteReturnType<T> {
   const [suiteCallback, suiteName] = args.reverse() as [T, string];
 
-  if (!isFunction(suiteCallback)) {
-    throwError('vest.create: Expected callback to be a function.');
-  }
+  invariant(
+    isFunction(suiteCallback),
+    'vest.create: Expected callback to be a function.'
+  );
 
   // Event bus initialization
   const bus = initBus();

packages/vest/src/core/suite/create.ts

@@ -1,4 +1,4 @@
-import throwError from 'throwError';
+import invariant from 'invariant';
 
 import { Severity } from 'Severity';
 import collectFailureMessages from 'collectFailureMessages';
@@ -41,13 +41,12 @@ function getByGroup(
   group: string,
   fieldName?: string
 ): Record<string, string[]> {
-  if (!group) {
-    throwError(
-      `get${severityKey[0].toUpperCase()}${severityKey.slice(
-        1
-      )}ByGroup requires a group name. Received \`${group}\` instead.`
-    );
-  }
+  invariant(
+    group,
+    `get${severityKey[0].toUpperCase()}${severityKey.slice(
+      1
+    )}ByGroup requires a group name. Received \`${group}\` instead.`
+  );
   const testObjects = useTestsFlat();
   return collectFailureMessages(severityKey, testObjects, {
     group,

packages/vest/src/core/suite/produce/getFailures/getFailuresByGroup.ts

@@ -147,11 +147,11 @@ describe('key', () => {
     });
 
     describe('When the same key is encountered twice', () => {
-      let throwErrorDeferred, vest;
+      let deferThrow, vest;
       beforeEach(() => {
         const mock = mockThrowError();
 
-        throwErrorDeferred = mock.throwErrorDeferred;
+        deferThrow = mock.deferThrow;
         vest = mock.vest;
       });
 
@@ -166,7 +166,7 @@ describe('key', () => {
           vest.test('field2', () => false, 'key_1');
         });
         suite();
-        expect(throwErrorDeferred).toHaveBeenCalledWith(
+        expect(deferThrow).toHaveBeenCalledWith(
           `Encountered the same test key "key_1" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.`
         );
       });