Trying out proxies instead to wrap the error chain object, and either strip or configure the error chain...

Author: CMCDragonkai

src/AbstractError.ts

@@ -6,7 +6,7 @@ import { CustomError } from 'ts-custom-error';
  * Abstract error
  * Intended for further extension
  */
-class AbstractError<T extends Error | void = void> extends CustomError {
+class AbstractError<T = void> extends CustomError {
   /**
    * Static description of exception
    */
@@ -56,6 +56,11 @@ class AbstractError<T extends Error | void = void> extends CustomError {
    * 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: {
@@ -94,6 +99,7 @@ class AbstractError<T extends Error | void = void> extends CustomError {
       if (this.cause instanceof AbstractError) {
         data.cause = this.cause.toJSON('cause', options);
       } else {
+        // Use `replacer` to further encode this object
         data.cause = this.cause;
       }
     }
@@ -104,7 +110,7 @@ class AbstractError<T extends Error | void = void> extends CustomError {
     };
   }
 
-  public static fromJSON(json: any): AbstractError<any> | undefined {
+  public static fromJSON(json: any): AbstractError<unknown> | undefined {
     if (typeof json !== 'object' || json == null) {
       return;
     }
@@ -122,8 +128,9 @@ class AbstractError<T extends Error | void = void> extends CustomError {
     }
     let timestamp;
     if (json.data.timestamp != null) {
-      if (!isNaN(Date.parse(json.data.timestamp))) {
-        timestamp = new Date(timestamp);
+      const timestampParsed = Date.parse(json.data.timestamp);
+      if (!isNaN(timestampParsed)) {
+        timestamp = new Date(timestampParsed);
       } else {
         return;
       }
@@ -134,24 +141,16 @@ class AbstractError<T extends Error | void = void> extends CustomError {
     if (json.data.stack != null && typeof json.data.stack !== 'string') {
       return;
     }
-    let cause;
-    if (json.data.cause != null) {
-      // THIS is a problem
-      // we don't know what the cause may be
-      // We don't know how to reconstruct it
-      // It is neither Error, nor AbstractError
-      // Do we check up the chain?
-      // The problem is that we can't really decode this if we don't know what the chain might be
-      // If e as an instance can be encoded with arbitrary error objects
-      // Then during decoding, how would we know how to reconstruct it?
-      // super.name
 
-      cause = this.fromJSON(json.data.cause);
-    }
+    // 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: cause,
+      cause: json.data.cause,
     });
     e.stack = json.data.stack;
     return e;

src/utils.ts

@@ -9,6 +9,11 @@ any key can be further processed
 }
 */
 
+// the replacer is designed for the cause chain
+// not for other exceptions
+// in fact using this is completely optional
+// we may even in fact not bother with this at all
+
 function replacer(options) {
   return (key: string, value: any): any => {
     if (value instanceof Error) {
@@ -25,6 +30,32 @@ function replacer(options) {
   };
 }
 
+// filterError
+
+function filterError (e, options) {
+  const handler = {
+    get(target, propKey, receiver) {
+      const targetValue = Reflect.get(target, propKey, receiver);
+      if (typeof targetValue === 'function') {
+        return function (...args) {
+          // Set certain options here
+          if (propKey === 'toJSON') {
+            args[1] = options;
+          }
+
+          // Again how does this actually, pass down to the other objects?
+
+          return targetValue.apply(this, args);
+        };
+      } else {
+        return targetValue;
+      }
+    }
+  }
+  return new Proxy(e, handler);
+}
+
 export {
-  replacer
+  replacer,
+  filterError
 };

test-json.ts

@@ -1,5 +1,5 @@
 import { AbstractError } from "./src";
-import { replacer } from './src/utils';
+import { replacer, filterError } from './src/utils';
 
 async function main () {
 
@@ -30,11 +30,17 @@ async function main () {
   // if you want to prevent stack though, or message that's up to you
 
   const j = JSON.stringify(
-    e3.toJSON(undefined, { stack: false, data: false }),
-    replacer,
+    filterError(e3, { stack: false }),
+    null,
     2
   );
 
+  // const j = JSON.stringify(
+  //   e3.toJSON(undefined, { stack: false, data: false }),
+  //   replacer,
+  //   2
+  // );
+
   console.log(j)
 
 }