Make decorator for error logging not create orphan promise for easier controllability

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

src/common/utils/with-error-logging/with-error-logging.injectable.ts

@@ -3,8 +3,8 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { isPromise } from "../is-promise/is-promise";
 import logErrorInjectable from "../../log-error.injectable";
+import { isPromise } from "../is-promise/is-promise";
 
 export type WithErrorLoggingFor = (
   getErrorMessage: (error: unknown) => string
@@ -21,18 +21,10 @@ const withErrorLoggingInjectable = getInjectable({
     return (getErrorMessage) =>
       (toBeDecorated) =>
         (...args) => {
+          let returnValue: ReturnType<typeof toBeDecorated>;
+
           try {
-            const returnValue = toBeDecorated(...args);
+            returnValue = toBeDecorated(...args);
-
-            if (isPromise(returnValue)) {
-              returnValue.catch((e) => {
-                const errorMessage = getErrorMessage(e);
-
-                logError(errorMessage, e);
-              });
-            }
-
-            return returnValue;
           } catch (e) {
             const errorMessage = getErrorMessage(e);
 
@@ -40,6 +32,18 @@ const withErrorLoggingInjectable = getInjectable({
 
             throw e;
           }
+
+          if (isPromise(returnValue)) {
+            return returnValue.catch((e: unknown) => {
+              const errorMessage = getErrorMessage(e);
+
+              logError(errorMessage, e);
+
+              throw e;
+            });
+          }
+
+          return returnValue;
         };
   },
 });

src/common/utils/with-error-logging/with-error-logging.test.ts

@@ -163,23 +163,24 @@ describe("with-error-logging", () => {
       });
 
       describe("when call rejects with error instance", () => {
-        let error: Error;
+        beforeEach(() => {
-
+          toBeDecorated.reject(new Error("some-error"));
-        beforeEach(async () => {
-          try {
-            await toBeDecorated.reject(new Error("some-error"));
-            await returnValuePromise;
-          } catch (e) {
-            error = e as Error;
-          }
         });
 
-        it("logs the error", () => {
+        it("logs the error", async () => {
+          let error: unknown;
+
+          try {
+            await returnValuePromise;
+          } catch (e) {
+            error = e;
+          }
+
           expect(loggerStub.error).toHaveBeenCalledWith("some-error-message-for-some-error", error);
         });
 
         it("rejects", () => {
-          return expect(() => returnValuePromise).rejects.toThrow("some-error");
+          return expect(returnValuePromise).rejects.toThrow("some-error");
         });
       });
 
@@ -187,8 +188,9 @@ describe("with-error-logging", () => {
         let error: unknown;
 
         beforeEach(async () => {
+          toBeDecorated.reject({ someProperty: "some-rejection" });
+
           try {
-            await toBeDecorated.reject({ someProperty: "some-rejection" });
             await returnValuePromise;
           } catch (e) {
             error = e;
@@ -203,7 +205,7 @@ describe("with-error-logging", () => {
         });
 
         it("rejects", () => {
-          return expect(() => returnValuePromise).rejects.toEqual({ someProperty: "some-rejection" });
+          return expect(returnValuePromise).rejects.toEqual({ someProperty: "some-rejection" });
         });
       });