style: prettified

src/logged.ts

@@ -1,14 +1,14 @@
-import {Logger} from "@nestjs/common";
+import { Logger } from "@nestjs/common";
-import {ScopedLogger} from "./logger";
+import { ScopedLogger } from "./logger";
-import {LoggedParamReflectData} from "./reflected";
+import { LoggedParamReflectData } from "./reflected";
-import {loggedParam, scopedLogger} from "./reflected";
+import { loggedParam, scopedLogger } from "./reflected";
 import objectContainedLogged from "./functions";
 
 function loggerInit(_target: any) {
-    if (!Object.getOwnPropertyNames(_target).includes('logger')) {
+  if (!Object.getOwnPropertyNames(_target).includes("logger")) {
     const newTargetLogger = new Logger(_target.constructor.name);
-        newTargetLogger.log('Logger Initialized.');
+    newTargetLogger.log("Logger Initialized.");
-        Object.defineProperty(_target, 'logger', {
+    Object.defineProperty(_target, "logger", {
       writable: false,
       enumerable: false,
       configurable: false,
@@ -20,7 +20,7 @@ function loggerInit(_target: any) {
 export function LoggedFunction<F extends Array<any>, R>(
   _target: any,
   key: string,
-    descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R>>,
+  descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R>>
 ) {
   loggerInit(_target);
 
@@ -34,50 +34,52 @@ export function LoggedFunction<F extends Array<any>, R>(
     const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
       scopedLogger,
       _target,
-            key,
+      key
     );
 
     if (
-            typeof scopedLoggerInjectableParam !== 'undefined' &&
+      typeof scopedLoggerInjectableParam !== "undefined" &&
       (args.length <= scopedLoggerInjectableParam ||
         !(args[scopedLoggerInjectableParam] instanceof ScopedLogger))
     ) {
       args[scopedLoggerInjectableParam] = new ScopedLogger(logger, key);
-        } else if (typeof scopedLoggerInjectableParam !== 'undefined') {
+    } else if (typeof scopedLoggerInjectableParam !== "undefined") {
       args[scopedLoggerInjectableParam] = new ScopedLogger(
         args[scopedLoggerInjectableParam],
-                key,
+        key
       );
     }
 
-        const injectedLogger=
+    const injectedLogger =
-            typeof scopedLoggerInjectableParam !== 'undefined'
+      typeof scopedLoggerInjectableParam !== "undefined"
         ? args[scopedLoggerInjectableParam]
         : logger;
 
     const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
       loggedParam,
       _target,
-            key,
+      key
-        )
+    );
 
     injectedLogger.log(
       `CALL ${key} ${
         loggedParams && loggedParams.length > 0
-                    ? 'WITH ' +
+          ? "WITH " +
             (
               await Promise.all(
                 loggedParams.map(
                   async ({ name, index, include, exclude }) =>
-                                    name + '=' + (await objectContainedLogged(args[index], {
+                    name +
+                    "=" +
+                    (await objectContainedLogged(args[index], {
                       include,
                       exclude,
-                                    })),
+                    }))
-                            ),
                 )
-                    ).join(', ')
+              )
-                    : ''
+            ).join(", ")
-            }`,
+          : ""
+      }`
     );
 
     try {
@@ -95,7 +97,7 @@ export function LoggedRoute<F extends Array<any>, R>(route: string) {
   return (
     _target: any,
     key: string,
-        descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R>>,
+    descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R>>
   ) => {
     loggerInit(_target);
 
@@ -110,45 +112,47 @@ export function LoggedRoute<F extends Array<any>, R>(route: string) {
       const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
         scopedLogger,
         _target,
-                key,
+        key
       );
 
       if (
-                typeof scopedLoggerInjectableParam !== 'undefined' &&
+        typeof scopedLoggerInjectableParam !== "undefined" &&
         (args.length <= scopedLoggerInjectableParam ||
           !(args[scopedLoggerInjectableParam] instanceof ScopedLogger))
       ) {
         args[scopedLoggerInjectableParam] = new ScopedLogger(logger, fullRoute);
       }
 
-            const injectedLogger=
+      const injectedLogger =
-                typeof scopedLoggerInjectableParam !== 'undefined'
+        typeof scopedLoggerInjectableParam !== "undefined"
           ? args[scopedLoggerInjectableParam]
           : logger;
 
       const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
         loggedParam,
         _target,
-                key,
+        key
-            )
+      );
 
       injectedLogger.log(
         `HIT HTTP ${fullRoute} (${key}) ${
           loggedParams && loggedParams.length > 0
-                        ? 'WITH ' +
+            ? "WITH " +
               (
                 await Promise.all(
                   loggedParams.map(
                     async ({ name, index, include, exclude }) =>
-                                        name + '=' + (await objectContainedLogged(args[index], {
+                      name +
+                      "=" +
+                      (await objectContainedLogged(args[index], {
                         include,
                         exclude,
-                                        })),
+                      }))
-                                ),
                   )
-                        ).join(', ')
+                )
-                        : ''
+              ).join(", ")
-                }`,
+            : ""
+        }`
       );
 
       try {
@@ -160,5 +164,5 @@ export function LoggedRoute<F extends Array<any>, R>(route: string) {
         throw e;
       }
     };
-    }
+  };
 }