WIP

Author: CMCDragonkai

src/AbstractError.ts

@@ -49,112 +49,6 @@ class AbstractError<T = void> extends CustomError {
   public get description(): string {
     return this.constructor['description'];
   }
-
-  /**
-   * Called automatically by JSON.stringify
-   * Options can be used to explicitly remove sensitive information
-   * Not all causes can be stringified
-   * You must use the replacer to encode the cause property
-   */
-
-
-  // We should use a Proxy, to "proxy the object" or the exception chain
-  // And then specialise the toJSON, rather than doing this?
-
-  public toJSON(
-    _key: string = '',
-    options: {
-      description?: boolean;
-      message?: boolean,
-      timestamp?: boolean;
-      data?: boolean;
-      cause?: boolean;
-      stack?: boolean;
-    } = {}
-  ): {
-    type: string;
-    data: {
-      description?: string;
-      message?: string;
-      timestamp?: Date,
-      data?: POJO;
-      cause?: T,
-      stack?: string
-    }
-  } {
-    options.description ??= true;
-    options.message ??= true;
-    options.timestamp ??= true;
-    options.data ??= true;
-    options.cause ??= true;
-    options.stack ??= true;
-    const data: POJO = {};
-    if (options.description) data.description = this.description;
-    if (options.message) data.message = this.message;
-    if (options.timestamp) data.timestamp = this.timestamp;
-    if (options.data) data.data = this.data;
-    if (options.cause) {
-      // Propagate the options down the exception chain
-      // but only if the cause is another AbstractError
-      if (this.cause instanceof AbstractError) {
-        data.cause = this.cause.toJSON('cause', options);
-      } else {
-        // Use `replacer` to further encode this object
-        data.cause = this.cause;
-      }
-    }
-    if (options.stack) data.stack = this.stack;
-    return {
-      type: this.name,
-      data
-    };
-  }
-
-  public static fromJSON(json: any): AbstractError<unknown> | undefined {
-    if (typeof json !== 'object' || json == null) {
-      return;
-    }
-    if (!('type' in json) || !('data' in json)) {
-      return;
-    }
-    if (json.type !== this.name) {
-      return;
-    }
-    if (typeof json.data !== 'object') {
-      return;
-    }
-    if (json.data.message != null && typeof json.data.message !== 'string') {
-      return;
-    }
-    let timestamp;
-    if (json.data.timestamp != null) {
-      const timestampParsed = Date.parse(json.data.timestamp);
-      if (!isNaN(timestampParsed)) {
-        timestamp = new Date(timestampParsed);
-      } else {
-        return;
-      }
-    }
-    if (json.data.data != null && typeof json.data.data !== 'object') {
-      return;
-    }
-    if (json.data.stack != null && typeof json.data.stack !== 'string') {
-      return;
-    }
-
-    // The cause cannot be reconstructed, unless it's the same as this exception class
-    // Even then, that would only be the case, if we use toError() again on it
-    // and no it's not part of the chain of exceptions
-    // An alternative is class decoration
-
-    const e = new this(json.data.message, {
-      data: json.data.data ?? {},
-      timestamp: timestamp,
-      cause: json.data.cause,
-    });
-    e.stack = json.data.stack;
-    return e;
-  }
 }
 
 export default AbstractError;

src/index.ts

@@ -1,3 +1,2 @@
 export { default as AbstractError } from './AbstractError';
-export * from './utils';
 export * from './types';

src/utils.ts

@@ -26,21 +26,6 @@ describe('index', () => {
       expect(e.cause).toBeInstanceOf(Error);
     }
   });
-  test('json', () => {
-    try {
-      throw new AbstractError();
-    } catch (e) {
-      const eObject = JSON.parse(JSON.stringify(e));
-      expect(eObject.name).toBe(AbstractError.name);
-      expect(eObject.description).toBe('');
-      expect(eObject.data).toStrictEqual({});
-      expect(eObject.cause).toBeUndefined();
-      expect(eObject.stack).toBeDefined();
-      // Timestamp is stringified to ISO8601
-      expect(e.timestamp.toISOString()).toBe(eObject.timestamp);
-      expect(new Date(eObject.timestamp).getTime()).toBe(e.timestamp.getTime());
-    }
-  });
   test('extending', () => {
     class ErrorProgram extends AbstractError {
       public static description = 'static description';
@@ -70,27 +55,4 @@ describe('index', () => {
       expect(e.cause).toBe(eOriginal);
     }
   });
-  test('causation chain serialize', () => {
-    const eOriginal = new AbstractError('original');
-    try {
-      try {
-        throw eOriginal;
-      } catch (e) {
-        const e_ = new AbstractError('wrapped', { cause: e as AbstractError });
-        expect(e_.cause).toBeInstanceOf(AbstractError);
-        expect(e_.cause).toBe(eOriginal);
-        expect(e_.cause.message).toBe('original');
-        throw e_;
-      }
-    } catch (e) {
-      const eObject = JSON.parse(JSON.stringify(e));
-      expect(eObject.cause.name).toBe(eOriginal.name);
-      expect(eObject.cause.description).toBe('');
-      expect(eObject.cause.message).toBe('original');
-      expect(eObject.message).toBe('wrapped');
-      expect(eObject.cause.data).toStrictEqual({});
-      expect(eObject.cause.cause).toBeUndefined();
-      expect(eObject.cause.stack).toBeDefined();
-    }
-  });
 });