fix: allow non-promise returning

src/functions.ts

@@ -51,6 +51,51 @@ export async function includeOrExcludeObject(
     : ocv;
 }
 
+export function includeOrExcludeObjectSync(
+  ocv: any,
+  paths: string[],
+  currentPath: string[] = [],
+  include: boolean // or exclude
+) {
+  if (Array.isArray(ocv)) {
+    return (
+      ocv.map(
+        (v, i) =>
+          includeOrExcludeObjectSync(
+            v,
+            paths,
+            [...currentPath, i.toString()],
+            include
+          )
+      )
+    ).filter((e) => e !== notIncludedSymbol);
+  }
+
+  if (typeof ocv === "object") {
+    return Object.fromEntries(
+      Object.entries(ocv).map(([key, value]) => [
+        key,
+        includeOrExcludeObject(
+          value,
+          paths,
+          [...currentPath, key],
+          include
+        ),
+      ]).filter((e) => e[1] !== notIncludedSymbol)
+    );
+  }
+
+  const isIncluded = paths.includes(currentPath.join("."));
+
+  return include
+    ? isIncluded // include mode, path is in list
+      ? ocv
+      : notIncludedSymbol
+    : isIncluded // exclude mode, path is in list
+    ? notIncludedSymbol
+    : ocv;
+}
+
 export default async function objectContainedLogged(
   ocv: any,
   options?: { include?: string[]; exclude: string[] }
@@ -75,9 +120,43 @@ export default async function objectContainedLogged(
   }
 }
 
+export function objectContainedLoggedSync(
+  ocv: any,
+  options?: { include?: string[]; exclude: string[] }
+): string {
+  if (options && typeof ocv === "object") {
+    if (options.include && options.include.length > 0) {
+      return JSON.stringify(
+        includeOrExcludeObjectSync(ocv, options.include, [], true)
+      );
+    }
+    if (options.exclude && options.exclude.length > 0) {
+      return JSON.stringify(
+        includeOrExcludeObjectSync(ocv, options.exclude, [], false)
+      );
+    }
+  }
+
+  if (typeof ocv === "object") {
+    return JSON.stringify(ocv);
+  } else {
+    return `${ocv}`;
+  }
+}
+
 export async function getItemByPath(obj: object, path: string | string[]) {
   const paths = Array.isArray(path) ? path : path.split(".");
 
+  return Object.keys(obj).includes(paths[0])
+    ? typeof obj[paths[0]] === "object"
+      ? await getItemByPath(obj[paths[0]], paths.slice(1))
+      : obj[paths[0]]
+    : undefined;
+}
+
+export function getItemByPathSync(obj: object, path: string | string[]) {
+  const paths = Array.isArray(path) ? path : path.split(".");
+
   return Object.keys(obj).includes(paths[0])
     ? typeof obj[paths[0]] === "object"
       ? getItemByPath(obj[paths[0]], paths.slice(1))

src/logged.ts

@@ -14,7 +14,7 @@ import {
   scopeKey,
 } from "./reflected";
 import { loggedParam, scopedLogger } from "./reflected";
-import objectContainedLogged, { getItemByPath } from "./functions";
+import { objectContainedLoggedSync, getItemByPathSync } from "./functions";
 import { RequestMethod } from "@nestjs/common";
 
 const RevRequestMethod = [
@@ -122,7 +122,7 @@ interface FunctionMetadata {
 }
 
 function overrideBuild<F extends Array<any>, R>(
-  originalFunction: (...args: F) => Promise<R> | R,
+  originalFunction: (...args: F) => R,
   baseLogger: Logger,
   metadatas: FunctionMetadata,
   key: string,
@@ -130,8 +130,8 @@ function overrideBuild<F extends Array<any>, R>(
   route?: {
     fullRoute: string;
   }
-) {
+): (...args: F) => R {
-  return async function (...args: F) {
+  return function (...args: F): R {
     let injectedLogger: Logger = baseLogger;
     if (typeof metadatas.scopedLoggerInjectableParam !== "undefined") {
       if (
@@ -161,55 +161,79 @@ function overrideBuild<F extends Array<any>, R>(
       } ${
         metadatas.loggedParams && metadatas.loggedParams.length > 0
           ? "WITH " +
-            (
+            metadatas.loggedParams.map(
-              await Promise.all(
+              ({ name, index, include, exclude }) =>
-                metadatas.loggedParams.map(
+                name +
-                  async ({ name, index, include, exclude }) =>
+                "=" +
-                    name +
+                objectContainedLoggedSync(args[index], {
-                    "=" +
+                  include,
-                    (await objectContainedLogged(args[index], {
+                  exclude,
-                      include,
+                })
-                      exclude,
-                    }))
-                )
-              )
             ).join(", ")
           : ""
       }`
     );
 
     try {
-      const r: R = await originalFunction.call(this, ...args);
+      const r: R = originalFunction.call(this, ...args);
-
+      if (
-      const resultLogged = Array.isArray(returnsData)
+        originalFunction.constructor.name === 'AsyncFunction' ||
-        ? typeof r === "object"
+        (typeof r === 'object' && typeof r['then'] === 'function')
-          ? "WITH " +
+      ) {
-            (
+        return r['then']((r: any) => {
-              await Promise.all(
+          const resultLogged = Array.isArray(returnsData)
-                returnsData.map(async ({ name, path }) => {
+            ? typeof r === "object"
-                  const value = await getItemByPath(r, path);
+              ? "WITH " +
+                returnsData.map(({ name, path }) => {
+                  const value = getItemByPathSync(r, path);
 
                   return value !== undefined ? `${name}=${value}` : "";
                 })
-              )
+                  .filter((v) => v.length > 0)
-            )
+                  .join(", ")
-              .filter((v) => v.length > 0)
+              : ""
-              .join(", ")
+            : typeof returnsData === 'string'
-          : ""
+              ? "WITH " + returnsData + "=" + typeof r === "object" ? JSON.stringify(r) : r
-        : typeof returnsData === 'string'
+              : returnsData
-          ? "WITH " + returnsData + "=" + typeof r === "object" ? JSON.stringify(r) : r
+                ? typeof r === "object"
-          : returnsData
+                  ? "WITH " + JSON.stringify(r)
-            ? typeof r === "object"
+                  : "WITH " + r
-              ? "WITH " + JSON.stringify(r)
+                : "";
-              : "WITH " + r
-            : "";
 
-      injectedLogger.log(
+          injectedLogger.log(
-        route
+            route
-          ? `RETURNED HTTP ${route.fullRoute} (${key}) ${resultLogged}`
+              ? `RETURNED HTTP ${route.fullRoute} (${key}) ${resultLogged}`
-          : `RETURNED ${key} ${resultLogged}`
+              : `RETURNED ${key} ${resultLogged}`
-      );
+          );
-      return r;
+          return r;
+        })
+      } else {
+        const resultLogged = Array.isArray(returnsData)
+          ? typeof r === "object"
+            ? "WITH " +
+              returnsData.map(({ name, path }) => {
+                const value = getItemByPathSync(r, path);
+
+                return value !== undefined ? `${name}=${value}` : "";
+              })
+                .filter((v) => v.length > 0)
+                .join(", ")
+            : ""
+          : typeof returnsData === 'string'
+            ? "WITH " + returnsData + "=" + typeof r === "object" ? JSON.stringify(r) : r
+            : returnsData
+              ? typeof r === "object"
+                ? "WITH " + JSON.stringify(r)
+                : "WITH " + r
+              : "";
+
+        injectedLogger.log(
+          route
+            ? `RETURNED HTTP ${route.fullRoute} (${key}) ${resultLogged}`
+            : `RETURNED ${key} ${resultLogged}`
+        );
+        return r;
+      }
     } catch (e) {
       injectedLogger.error(
         `WHILE ${route ? `HTTP ${route.fullRoute} (${key})` : key} ERROR ${e}`

src/test/index.ts

@@ -163,6 +163,15 @@ class LoggedClass {
     await this.testLoggerRootLogging2(logger);
   }
 
+  testSyncLoggerRootLogging2(@InjectLogger logger?: ScopedLogger) {
+    logger.log('2')
+    return 2
+  }
+
+  testSyncLoggerRootLogging(@InjectLogger logger?: ScopedLogger) {
+    logger.log(this.testSyncLoggerRootLogging2(logger).toString())
+  }
+
   testSyncLogging(@InjectLogger logger?: ScopedLogger) {
     logger.log("synced yay");
   }
@@ -325,6 +334,17 @@ class LoggedMethodsClass {
     await this.testLoggerRootLogging2(logger);
   }
 
+  @LoggedFunction
+  testSyncLoggerRootLogging2(@InjectLogger logger?: ScopedLogger) {
+    logger.log('2')
+    return 2
+  }
+
+  @LoggedFunction
+  testSyncLoggerRootLogging(@InjectLogger logger?: ScopedLogger) {
+    logger.log(this.testSyncLoggerRootLogging2(logger).toString())
+  }
+
   @LoggedFunction
   testSyncLogging(@InjectLogger logger?: ScopedLogger) {
     logger.log("synced yay");
@@ -353,7 +373,8 @@ const tester = new LoggedClass();
 // void tester.testMissingReturnLogging("asdf");
 // void tester.testRawObjectReturnLogging("asdf");
 // void tester.testRawValueReturnLogging("asdf");
-// void tester.testLoggerRootLogging();
+void tester.testLoggerRootLogging();
+// tester.testSyncLoggerRootLogging();
 // tester.testSyncLogging();
 
 /**