Allow passing a cause to predefined error functions (#83)

* Allow passing a cause to predefined error functions

This allows passing an `Error` class object to one of the predefined error functions as defined in `rpcErrors` and `providerErrors`. Upon calling the `serialise` function of the `JsonRpcError` class, the cause error will be serialised using the `serializeCause` function.

* Add tests to ensure error.serialize().data is not an instance of Error

The expect function ensures that the type of error.serialize().data is an object and contains specific serialized data while ensuring it does not contain an error instance. This test is necessary to avoid unexpected errors during exception handling.

* Apply suggestions from code review

Co-authored-by: Frederik Bolding <frederik.bolding@gmail.com>

* Export `serializeCause` and `DataWithOptionalCause`

* Fix type errors

* Update coverage tresholds

---------

Co-authored-by: Frederik Bolding <frederik.bolding@gmail.com>

Author: Mrtenz

jest.config.js

@@ -22,7 +22,11 @@ module.exports = {
   collectCoverage: true,
 
   // An array of glob patterns indicating a set of files for which coverage information should be collected
-  collectCoverageFrom: ['./src/**/*.ts', '!./src/__fixtures__/**/*'],
+  collectCoverageFrom: [
+    './src/**/*.ts',
+    '!./src/__fixtures__/**/*',
+    '!./src/index.ts',
+  ],
 
   // The directory where Jest should output its coverage files
   coverageDirectory: 'coverage',
@@ -41,10 +45,10 @@ module.exports = {
   // An object that configures minimum threshold enforcement for coverage results
   coverageThreshold: {
     global: {
-      branches: 94.5,
-      functions: 85.36,
-      lines: 96.88,
-      statements: 96.88,
+      branches: 94.25,
+      functions: 94.11,
+      lines: 97.02,
+      statements: 97.02,
     },
   },
 

src/classes.ts

@@ -1,5 +1,10 @@
 import safeStringify from 'fast-safe-stringify';
-import { Json, JsonRpcError as SerializedJsonRpcError } from '@metamask/utils';
+import {
+  isPlainObject,
+  Json,
+  JsonRpcError as SerializedJsonRpcError,
+} from '@metamask/utils';
+import { DataWithOptionalCause, serializeCause } from './utils';
 
 export { SerializedJsonRpcError };
 
@@ -9,7 +14,7 @@ export { SerializedJsonRpcError };
  *
  * Permits any integer error code.
  */
-export class JsonRpcError<T extends Json> extends Error {
+export class JsonRpcError<T extends DataWithOptionalCause> extends Error {
   public code: number;
 
   public data?: T;
@@ -40,13 +45,22 @@ export class JsonRpcError<T extends Json> extends Error {
       code: this.code,
       message: this.message,
     };
+
     if (this.data !== undefined) {
-      serialized.data = this.data;
+      // `this.data` is not guaranteed to be a plain object, but this simplifies
+      // the type guard below. We can safely cast it because we know it's a
+      // JSON-serializable value.
+      serialized.data = this.data as { [key: string]: Json };
+
+      if (isPlainObject(this.data)) {
+        serialized.data.cause = serializeCause(this.data.cause);
+      }
     }
 
     if (this.stack) {
       serialized.stack = this.stack;
     }
+
     return serialized;
   }
 
@@ -65,7 +79,9 @@ export class JsonRpcError<T extends Json> extends Error {
  * Error subclass implementing Ethereum Provider errors per EIP-1193.
  * Permits integer error codes in the [ 1000 <= 4999 ] range.
  */
-export class EthereumProviderError<T extends Json> extends JsonRpcError<T> {
+export class EthereumProviderError<
+  T extends DataWithOptionalCause,
+> extends JsonRpcError<T> {
   /**
    * Create an Ethereum Provider JSON-RPC error.
    *

src/errors.test.ts

@@ -1,3 +1,4 @@
+import { assert, isPlainObject } from '@metamask/utils';
 import { getMessageFromCode, JSON_RPC_SERVER_ERROR_MESSAGE } from './utils';
 import {
   dummyData,
@@ -45,7 +46,7 @@ describe('custom provider error options', () => {
   });
 });
 
-describe('ethError.rpc.server', () => {
+describe('rpcErrors.server', () => {
   it('throws on invalid input', () => {
     expect(() => {
       // @ts-expect-error Invalid input
@@ -63,6 +64,16 @@ describe('ethError.rpc.server', () => {
       rpcErrors.server({ code: 1 });
     }).toThrow('"code" must be an integer such that: -32099 <= code <= -32005');
   });
+
+  it('returns appropriate value', () => {
+    const error = rpcErrors.server({
+      code: SERVER_ERROR_CODE,
+      data: Object.assign({}, dummyData),
+    });
+
+    expect(error.code <= -32000 && error.code >= -32099).toBe(true);
+    expect(error.message).toBe(JSON_RPC_SERVER_ERROR_MESSAGE);
+  });
 });
 
 describe('rpcErrors', () => {
@@ -85,14 +96,26 @@ describe('rpcErrors', () => {
     },
   );
 
-  it('server returns appropriate value', () => {
-    const error = rpcErrors.server({
-      code: SERVER_ERROR_CODE,
-      data: Object.assign({}, dummyData),
+  it('serializes a cause', () => {
+    const error = rpcErrors.invalidInput({
+      data: {
+        foo: 'bar',
+        cause: new Error('foo'),
+      },
     });
 
-    expect(error.code <= -32000 && error.code >= -32099).toBe(true);
-    expect(error.message).toBe(JSON_RPC_SERVER_ERROR_MESSAGE);
+    const serializedError = error.serialize();
+    assert(serializedError.data);
+    assert(isPlainObject(serializedError.data));
+
+    expect(serializedError.data.cause).not.toBeInstanceOf(Error);
+    expect(serializedError.data).toStrictEqual({
+      foo: 'bar',
+      cause: {
+        message: 'foo',
+        stack: expect.stringContaining('Error: foo'),
+      },
+    });
   });
 });
 
@@ -123,4 +146,26 @@ describe('providerErrors', () => {
     expect(error.code).toBe(CUSTOM_ERROR_CODE);
     expect(error.message).toBe(CUSTOM_ERROR_MESSAGE);
   });
+
+  it('serializes a cause', () => {
+    const error = providerErrors.unauthorized({
+      data: {
+        foo: 'bar',
+        cause: new Error('foo'),
+      },
+    });
+
+    const serializedError = error.serialize();
+    assert(serializedError.data);
+    assert(isPlainObject(serializedError.data));
+
+    expect(serializedError.data.cause).not.toBeInstanceOf(Error);
+    expect(serializedError.data).toStrictEqual({
+      foo: 'bar',
+      cause: {
+        message: 'foo',
+        stack: expect.stringContaining('Error: foo'),
+      },
+    });
+  });
 });