imp: clear place for errors

Author: apademide

src/errors/PipelineError.ts

@@ -0,0 +1,36 @@
+export class PipelineError<T = unknown> extends Error {
+  public readonly name = "PipelineError";
+
+  /** The function that caused the error in the pipeline. */
+  public readonly fn: Function;
+
+  /** The value of `this`` when the error occurred. */
+  public readonly thisValue: unknown;
+
+  /** The input that was provided to the function that caused the error. */
+  public readonly input: T;
+
+  constructor({
+    fn,
+    input,
+    thisValue,
+    cause,
+  }: {
+    fn: Function;
+    input: T;
+    thisValue: unknown;
+    cause: unknown;
+  }) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+
+    super(`Pipeline step failed: ${message}`, { cause });
+
+    this.fn = fn;
+    this.input = input;
+    this.cause = cause;
+
+    if (cause instanceof Error) {
+      this.stack = cause.stack;
+    }
+  }
+}

src/functions/pipe.ts

@@ -1,3 +1,5 @@
+import { PipelineError } from "~/errors/PipelineError";
+
 export type TransformFn<This, In, Out> =
   | ((this: This, value: In) => Out)
   | ((value: In) => Out);
@@ -88,7 +90,16 @@ export function pipe(this: any, ...fns: PipeEntry<any, any, any>[]) {
         fn = entry;
       }
 
-      return fn.call(this, carry);
+      try {
+        return fn.call(this, carry);
+      } catch (error) {
+        throw new PipelineError({
+          fn,
+          input: carry,
+          thisValue: this,
+          cause: error,
+        });
+      }
     }, initialValue);
   };
 }

src/functions/pipeAsync.ts

@@ -1,3 +1,4 @@
+import { PipelineError } from "~/errors/PipelineError";
 import type { PipeCondition } from "./pipe";
 
 export type AsyncTransformFn<This, In, Out> =
@@ -90,35 +91,15 @@ export function pipeAsync(this: any, ...fns: AsyncPipeEntry<any, any, any>[]) {
       try {
         carry = await fn.call(this, carry);
       } catch (error) {
-        throw new PipelineError(fn, error);
+        throw new PipelineError({
+          fn,
+          input: carry,
+          thisValue: this,
+          cause: error,
+        });
       }
     }
 
     return carry;
   };
 }
-
-/**
- * Is thrown when an error occurs within a piped function.
- * It wraps the original error and exposes the function that caused the error.
- */
-export class PipelineError extends Error {
-  constructor(
-    public readonly functionThatFailed: Function,
-    originalError: unknown
-  ) {
-    const message = `An error occurred in a piped function: ${
-      originalError instanceof Error
-        ? originalError.message
-        : String(originalError)
-    }`;
-
-    super(message);
-
-    this.name = "PipelineError";
-
-    if (originalError instanceof Error && originalError.stack) {
-      this.stack = originalError.stack;
-    }
-  }
-}

src/index.ts

@@ -45,7 +45,6 @@ export {
 } from "~/functions/pipe.js";
 export {
   pipeAsync,
-  PipelineError,
   type AsyncPipeEntry,
   type AsyncTransformFn,
 } from "~/functions/pipeAsync.js";
@@ -59,3 +58,5 @@ export { tap } from "~/functions/tap.js";
 export { throttle } from "~/functions/throttle.js";
 export { value, type Value } from "~/functions/value.js";
 export { when } from "~/functions/when.js";
+
+export { PipelineError } from "~/errors/PipelineError.js";