yerror 7.0.0 → 9.0.0

package/src/index.test.ts

@@ -1,137 +1,120 @@
-/* eslint max-nested-callbacks:[0], no-magic-numbers:[0] */
-import { describe, test } from '@jest/globals';
-import assert from 'assert';
+import { describe, test, expect } from '@jest/globals';
 import { YError } from './index.js';
 
 describe('YError', () => {
   describe('.__constructor', () => {
     test('Should work', () => {
-      const err = new YError('E_ERROR', 'arg1', 'arg2');
+      const err = new YError('E_ERROR', ['arg1', 'arg2']);
 
-      assert(err instanceof Error);
-      assert.equal(err.name, err.toString());
-      assert.equal(err.code, 'E_ERROR');
-      assert.deepEqual(err.params, ['arg1', 'arg2']);
-      assert.equal(err.toString(), 'YError: E_ERROR (arg1, arg2)');
+      expect(err instanceof Error).toBeTruthy();
+      expect(err.name).toEqual(err.toString());
+      expect(err.code).toEqual('E_ERROR');
+      expect(err.debugValues).toEqual(['arg1', 'arg2']);
+      expect(err.toString()).toEqual('YError: E_ERROR (["arg1","arg2"])');
     });
     test('Should work without code', () => {
       const err = new YError();
 
-      assert.equal(err.code, 'E_UNEXPECTED');
-      assert.deepEqual(err.params, []);
-      assert.equal(err.toString(), 'YError: E_UNEXPECTED ()');
-      assert.equal(err.name, err.toString());
+      expect(err.code).toEqual('E_UNEXPECTED');
+      expect(err.debugValues).toEqual([]);
+      expect(err.toString()).toEqual('YError: E_UNEXPECTED ([])');
+      expect(err.name).toEqual(err.toString());
     });
     test('Should work without new', () => {
-      const err = new YError('E_ERROR', 'arg1', 'arg2');
+      const err = new YError('E_ERROR', ['arg1', 'arg2']);
 
-      assert.equal(err.code, 'E_ERROR');
-      assert(err instanceof YError);
-      assert.deepEqual(err.params, ['arg1', 'arg2']);
-      assert.equal(err.toString(), 'YError: E_ERROR (arg1, arg2)');
-      assert.equal(err.name, err.toString());
+      expect(err.code).toEqual('E_ERROR');
+      expect(err instanceof YError).toBeTruthy();
+      expect(err.debugValues).toEqual(['arg1', 'arg2']);
+      expect(err.toString()).toEqual('YError: E_ERROR (["arg1","arg2"])');
+      expect(err.name).toEqual(err.toString());
     });
   });
 
   describe('.wrap()', () => {
     test('Should work with standard errors and a message', () => {
-      // eslint-disable-line
       const err = YError.wrap(new Error('This is an error!'));
 
-      assert.equal(err.code, 'E_UNEXPECTED');
-      assert.equal(err.wrappedErrors.length, 1);
-      assert.deepEqual(err.params, ['This is an error!']);
+      expect(err.code).toEqual('E_UNEXPECTED');
+      expect(err.wrappedErrors.length).toEqual(1);
+      expect(err.debugValues).toEqual([]);
 
       if ('captureStackTrace' in Error) {
-        assert(
+        expect(
           -1 !== (err.stack || '').indexOf('Error: This is an error!'),
-          'Stack contains original error.',
-        );
-        assert(
-          -1 !==
-            (err.stack || '').indexOf(
-              'YError: E_UNEXPECTED (This is an error!)',
-            ),
-          'Stack contains cast error.',
-        );
-        assert.equal(err.name, err.toString());
+        ).toBeTruthy();
+        expect(
+          -1 !== (err.stack || '').indexOf('YError: E_UNEXPECTED ([])'),
+        ).toBeTruthy();
+        expect(err.name).toEqual(err.toString());
       }
     });
 
     test('Should work with standard errors and an error code', () => {
       const err = YError.wrap(new Error('E_ERROR'));
 
-      assert.equal(err.code, 'E_ERROR');
-      assert.equal(err.wrappedErrors.length, 1);
-      assert.deepEqual(err.params, []);
+      expect(err.code).toEqual('E_ERROR');
+      expect(err.wrappedErrors.length).toEqual(1);
+      expect(err.debugValues).toEqual([]);
 
       if ('captureStackTrace' in Error) {
-        assert(
-          -1 !== (err.stack || '').indexOf('Error: E_ERROR'),
-          'Stack contains original error.',
-        );
-        assert(
-          -1 !== (err.stack || '').indexOf('YError: E_ERROR ()'),
-          'Stack contains cast error.',
-        );
+        expect(-1 !== (err.stack || '').indexOf('Error: E_ERROR')).toBeTruthy();
+        expect(
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR ([])'),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
 
     test('Should work with standard errors, an error code and params', () => {
-      const err = YError.wrap(
-        new Error('E_ERROR'),
-        'E_ERROR_2',
+      const err = YError.wrap(new Error('E_ERROR'), 'E_ERROR_2', [
         'arg1',
         'arg2',
-      );
+      ]);
 
-      assert.equal(err.code, 'E_ERROR_2');
-      assert.equal(err.wrappedErrors.length, 1);
-      assert.deepEqual(err.params, ['arg1', 'arg2']);
+      expect(err.code).toEqual('E_ERROR_2');
+      expect(err.wrappedErrors.length).toEqual(1);
+      expect(err.debugValues).toEqual(['arg1', 'arg2']);
 
       if ('captureStackTrace' in Error) {
-        assert(
-          -1 !== (err.stack || '').indexOf('Error: E_ERROR'),
-          'Stack contains first error.',
-        );
-        assert(
-          -1 !== (err.stack || '').indexOf('YError: E_ERROR_2 (arg1, arg2)'),
-          'Stack contains second error.',
-        );
+        expect(-1 !== (err.stack || '').indexOf('Error: E_ERROR')).toBeTruthy();
+        expect(
+          -1 !==
+            (err.stack || '').indexOf('YError: E_ERROR_2 (["arg1","arg2"])'),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
 
     test('Should work with several wrapped errors', () => {
       const err = YError.wrap(
-        YError.wrap(new Error('E_ERROR_1'), 'E_ERROR_2', 'arg2.1', 'arg2.2'),
+        YError.wrap(new Error('E_ERROR_1'), 'E_ERROR_2', ['arg2.1', 'arg2.2']),
         'E_ERROR_3',
-        'arg3.1',
-        'arg3.2',
+        ['arg3.1', 'arg3.2'],
       );
 
-      assert.equal(err.code, 'E_ERROR_3');
-      assert.equal(err.wrappedErrors.length, 2);
-      assert.deepEqual(err.params, ['arg3.1', 'arg3.2']);
+      expect(err.code).toEqual('E_ERROR_3');
+      expect(err.wrappedErrors.length).toEqual(2);
+      expect(err.debugValues).toEqual(['arg3.1', 'arg3.2']);
 
       if ('captureStackTrace' in Error) {
-        assert(
+        expect(
           -1 !== (err.stack || '').indexOf('Error: E_ERROR_1'),
-          'Stack contains first error.',
-        );
-        assert(
+        ).toBeTruthy();
+        expect(
           -1 !==
-            (err.stack || '').indexOf('YError: E_ERROR_2 (arg2.1, arg2.2)'),
-          'Stack contains second error.',
-        );
-        assert(
+            (err.stack || '').indexOf(
+              'YError: E_ERROR_2 (["arg2.1","arg2.2"])',
+            ),
+        ).toBeTruthy();
+        expect(
           -1 !==
-            (err.stack || '').indexOf('YError: E_ERROR_3 (arg3.1, arg3.2)'),
-          'Stack contains second error.',
-        );
+            (err.stack || '').indexOf(
+              'YError: E_ERROR_3 (["arg3.1","arg3.2"])',
+            ),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
   });
 
@@ -139,39 +122,33 @@ describe('YError', () => {
     test('Should work with standard errors and a message', () => {
       const err = YError.cast(new Error('This is an error!'));
 
-      assert.equal(err.code, 'E_UNEXPECTED');
-      assert.equal(err.wrappedErrors.length, 1);
-      assert.deepEqual(err.params, ['This is an error!']);
+      expect(err.code).toEqual('E_UNEXPECTED');
+      expect(err.wrappedErrors.length).toEqual(1);
+      expect(err.debugValues).toEqual([]);
 
       if ('captureStackTrace' in Error) {
-        assert(
+        expect(
           -1 !== (err.stack || '').indexOf('Error: This is an error!'),
-          'Stack contains original error.',
-        );
-        assert(
-          -1 !==
-            (err.stack || '').indexOf(
-              'YError: E_UNEXPECTED (This is an error!)',
-            ),
-          'Stack contains cast error.',
-        );
+        ).toBeTruthy();
+        expect(
+          -1 !== (err.stack || '').indexOf('YError: E_UNEXPECTED ([])'),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
 
     test('Should let YError instances pass through', () => {
-      const err = YError.cast(new YError('E_ERROR', 'arg1', 'arg2'));
+      const err = YError.cast(new YError('E_ERROR', ['arg1', 'arg2']));
 
-      assert.equal(err.code, 'E_ERROR');
-      assert.deepEqual(err.params, ['arg1', 'arg2']);
+      expect(err.code).toEqual('E_ERROR');
+      expect(err.debugValues).toEqual(['arg1', 'arg2']);
 
       if ('captureStackTrace' in Error) {
-        assert(
-          -1 !== (err.stack || '').indexOf('YError: E_ERROR (arg1, arg2)'),
-          'Stack contains cast error.',
-        );
+        expect(
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR (["arg1","arg2"])'),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
   });
 
@@ -179,76 +156,68 @@ describe('YError', () => {
     test('Should work with standard errors and a message', () => {
       const err = YError.bump(new Error('This is an error!'));
 
-      assert.equal(err.code, 'E_UNEXPECTED');
-      assert.equal(err.wrappedErrors.length, 1);
-      assert.deepEqual(err.params, ['This is an error!']);
+      expect(err.code).toEqual('E_UNEXPECTED');
+      expect(err.wrappedErrors.length).toEqual(1);
+      expect(err.debugValues).toEqual([]);
 
       if ('captureStackTrace' in Error) {
-        assert(
+        expect(
           -1 !== (err.stack || '').indexOf('Error: This is an error!'),
-          'Stack contains original error.',
-        );
-        assert(
-          -1 !==
-            (err.stack || '').indexOf(
-              'YError: E_UNEXPECTED (This is an error!)',
-            ),
-          'Stack contains bumped error.',
-        );
+        ).toBeTruthy();
+        expect(
+          -1 !== (err.stack || '').indexOf('YError: E_UNEXPECTED ([])'),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
 
     test('Should work with YError like errors', () => {
       const baseErr = new Error('E_A_NEW_ERROR');
 
       (baseErr as YError).code = 'E_A_NEW_ERROR';
-      (baseErr as YError).params = ['baseParam1', 'baseParam2'];
+      (baseErr as YError).debugValues = ['baseParam1', 'baseParam2'];
 
       const err = YError.bump(baseErr);
 
-      assert.equal(err.code, 'E_A_NEW_ERROR');
-      assert.equal(err.wrappedErrors.length, 1);
-      assert.deepEqual(err.params, ['baseParam1', 'baseParam2']);
+      expect(err.code).toEqual('E_A_NEW_ERROR');
+      expect(err.wrappedErrors.length).toEqual(1);
+      expect(err.debugValues).toEqual(['baseParam1', 'baseParam2']);
 
       if ('captureStackTrace' in Error) {
-        assert(
+        expect(
           -1 !== (err.stack || '').indexOf('Error: E_A_NEW_ERROR'),
-          'Stack contains original error.',
-        );
-        assert(
+        ).toBeTruthy();
+        expect(
           -1 !==
             (err.stack || '').indexOf(
-              'YError: E_A_NEW_ERROR (baseParam1, baseParam2)',
+              'YError: E_A_NEW_ERROR (["baseParam1","baseParam2"])',
             ),
-          'Stack contains bumped error.',
-        );
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
 
     test('Should work with Y errors and a message', () => {
       const err = YError.bump(
-        new YError('E_ERROR', 'arg1.1', 'arg1.2'),
+        new YError('E_ERROR', ['arg1.1', 'arg1.2']),
         'E_ERROR_2',
-        'arg2.1',
-        'arg2.2',
+        ['arg2.1', 'arg2.2'],
       );
 
-      assert.equal(err.code, 'E_ERROR');
-      assert.deepEqual(err.params, ['arg1.1', 'arg1.2']);
+      expect(err.code).toEqual('E_ERROR');
+      expect(err.debugValues).toEqual(['arg1.1', 'arg1.2']);
 
       if ('captureStackTrace' in Error) {
-        assert(
-          -1 !== (err.stack || '').indexOf('YError: E_ERROR (arg1.1, arg1.2)'),
-          'Stack contains original error.',
-        );
-        assert(
-          -1 !== (err.stack || '').indexOf('YError: E_ERROR (arg1.1, arg1.2)'),
-          'Stack contains bumped error.',
-        );
+        expect(
+          -1 !==
+            (err.stack || '').indexOf('YError: E_ERROR (["arg1.1","arg1.2"])'),
+        ).toBeTruthy();
+        expect(
+          -1 !==
+            (err.stack || '').indexOf('YError: E_ERROR (["arg1.1","arg1.2"])'),
+        ).toBeTruthy();
       }
-      assert.equal(err.name, err.toString());
+      expect(err.name).toEqual(err.toString());
     });
   });
 });

package/src/index.ts

@@ -1,47 +1,35 @@
-import os from 'os';
+import { EOL } from 'node:os';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type YErrorParams = any;
+export type YErrorDebugValue = unknown;
 
 /**
- * A YError class able to contain some params and
+ * A YError class able to contain some debugValues and
  *  print better stack traces
  * @extends Error
  */
-class YError extends Error {
+class YError<T = YErrorDebugValue> extends Error {
   code: string;
-  params: YErrorParams[];
-  wrappedErrors: (Error | YError)[];
+  debugValues: T[] = [];
+  wrappedErrors: (Error | YError)[] = [];
   /**
    * Creates a new YError with an error code
-   *  and some params as debug values.
+   *  and some debugValues as debug values.
    * @param {string} [errorCode = 'E_UNEXPECTED']
    * The error code corresponding to the actual error
-   * @param {...YErrorParams} [params]
+   * @param {any} [debugValues]
    * Some additional debugging values
    */
-  constructor(errorCode: string, ...params: YErrorParams[]);
   constructor(
-    wrappedErrors?: Error[],
     errorCode?: string,
-    ...params: YErrorParams[]
-  );
-  constructor(wrappedErrors, errorCode, ...params) {
-    // Detecting if wrappedErrors are passed
-    if (!(wrappedErrors instanceof Array)) {
-      params = ('undefined' === typeof errorCode ? [] : [errorCode]).concat(
-        params,
-      );
-      errorCode = wrappedErrors;
-      wrappedErrors = [];
-    }
-
+    debugValues: T[] = [],
+    wrappedErrors: (Error | YError)[] = [],
+  ) {
     // Call the parent constructor
     super(errorCode);
 
     // Filling error
     this.code = errorCode || 'E_UNEXPECTED';
-    this.params = params;
+    this.debugValues = debugValues;
     this.wrappedErrors = wrappedErrors;
     this.name = this.toString();
 
@@ -52,22 +40,22 @@ class YError extends Error {
 
   /**
    * Wraps any error and output a YError with an error
-   *  code and some params as debug values.
+   *  code and some debugValues as debug values.
    * @param {Error} err
    * The error to wrap
    * @param {string} [errorCode = 'E_UNEXPECTED']
    * The error code corresponding to the actual error
-   * @param {...YErrorParams} [params]
+   * @param {any} [debugValues]
    * Some additional debugging values
    * @return {YError}
    * The wrapped error
    */
-  static wrap<E extends Error | YError>(
-    err: E,
+  static wrap<T = YErrorDebugValue>(
+    err: Error | YError,
     errorCode?: string,
-    ...params: YErrorParams[]
+    debugValues: T[] = [],
   ): YError {
-    const wrappedErrorIsACode = _looksLikeAYErrorCode(err.message);
+    const wrappedErrorIsACode = looksLikeAYErrorCode(err.message);
     const wrappedErrors = (
       'wrappedErrors' in err ? err.wrappedErrors : []
     ).concat(err);
@@ -79,33 +67,31 @@ class YError extends Error {
         errorCode = 'E_UNEXPECTED';
       }
     }
-    if (err.message && !wrappedErrorIsACode) {
-      params.push(err.message);
-    }
-    return new YError(wrappedErrors, errorCode, ...params);
+
+    return new YError(errorCode, debugValues, wrappedErrors);
   }
 
   /**
    * Return a YError as is or wraps any other error and output
-   *  a YError with a code and some params as debug values.
+   *  a YError with a code and some debugValues as debug values.
    * @param {Error} err
    * The error to cast
    * @param {string} [errorCode = 'E_UNEXPECTED']
    * The error code corresponding to the actual error
-   * @param {...YErrorParams} [params]
+   * @param {any} [debugValues]
    * Some additional debugging values
    * @return {YError}
    * The wrapped error
    */
-  static cast<E extends Error | YError>(
-    err: E,
+  static cast<T = YErrorDebugValue>(
+    err: Error | YError,
     errorCode?: string,
-    ...params: YErrorParams[]
+    debugValues: T[] = [],
   ): YError {
-    if (_looksLikeAYError(err)) {
-      return err as unknown as YError;
+    if (looksLikeAYError(err)) {
+      return err;
     }
-    return YError.wrap(err, errorCode, ...params);
+    return YError.wrap(err, errorCode, debugValues);
   }
 
   /**
@@ -116,40 +102,41 @@ class YError extends Error {
    * The error to bump
    * @param {string} [errorCode = 'E_UNEXPECTED']
    * The error code corresponding to the actual error
-   * @param {...YErrorParams} [params]
+   * @param {any} [debugValues]
    * Some additional debugging values
    * @return {YError}
    * The wrapped error
    */
-  static bump<E extends Error | YError>(
-    err: E,
+  static bump<T = YErrorDebugValue>(
+    err: Error | YError,
     errorCode?: string,
-    ...params: YErrorParams[]
+    debugValues: T[] = [],
   ): YError {
-    if (_looksLikeAYError(err)) {
-      return YError.wrap(err, (err as YError).code, ...(err as YError).params);
+    if (looksLikeAYError(err)) {
+      return YError.wrap(err, err.code, err.debugValues);
     }
-    return YError.wrap(err, errorCode, ...params);
+    return YError.wrap(err, errorCode, debugValues);
   }
 
   toString(): string {
-    return (
-      (this.wrappedErrors.length
-        ? // eslint-disable-next-line
-          this.wrappedErrors[this.wrappedErrors.length - 1].stack + os.EOL
-        : '') +
-      this.constructor.name +
-      ': ' +
-      this.code +
-      ' (' +
-      this.params.join(', ') +
-      ')'
-    );
+    let debugValuesAsString: string;
+
+    try {
+      debugValuesAsString = JSON.stringify(this.debugValues);
+    } catch {
+      debugValuesAsString = '<circular>';
+    }
+
+    return `${
+      this.wrappedErrors.length
+        ? this.wrappedErrors[this.wrappedErrors.length - 1].stack + EOL
+        : ''
+    }${this.constructor.name}: ${this.code} (${debugValuesAsString})`;
   }
 }
 
 /**
- * Allow to print a stack from anything (especially catched
+ * Allow to print a stack from anything (especially caught
  *  errors that may or may not contain errors 🤷).
  * @param {Error} err
  * The error to print
@@ -167,8 +154,8 @@ export function printStackTrace(err: Error | YError): string {
 }
 
 // In order to keep compatibility through major versions
-// we have to make kind of an cross major version instanceof
-function _looksLikeAYError(err: Error | YError): boolean {
+// we have to make kind of a cross major version instanceof
+export function looksLikeAYError(err: Error | YError): err is YError {
   return (
     !!(err instanceof YError) ||
     !!(
@@ -177,15 +164,15 @@ function _looksLikeAYError(err: Error | YError): boolean {
       err.constructor.name.endsWith('Error') &&
       'code' in err &&
       'string' === typeof err.code &&
-      _looksLikeAYErrorCode(err.code) &&
-      'params' in err &&
-      err.params &&
-      err.params instanceof Array
+      looksLikeAYErrorCode(err.code) &&
+      'debugValues' in err &&
+      err.debugValues &&
+      err.debugValues instanceof Array
     )
   );
 }
 
-function _looksLikeAYErrorCode(str: string): boolean {
+export function looksLikeAYErrorCode(str: string): boolean {
   return /^([A-Z0-9_]+)$/.test(str);
 }