style: add prettier

.prettierrc

@@ -0,0 +1,11 @@
+{
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": true,
+  "quoteProps": "as-needed",
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "objectWrap": "preserve",
+  "arrowParens": "always"
+}

package.json

@@ -15,6 +15,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.9.1",
+    "prettier": "^3.5.3",
     "rimraf": "^5.0.5",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2"
@@ -24,7 +25,8 @@
     "build": "rimraf ./dist/lib && tsc --project tsconfig.build.json",
     "up": "yarn docs && yarn build && yarn npm publish dist",
     "up:beta": "yarn docs && yarn build && yarn npm publish dist --tag beta",
-    "test": "ts-node ./src/test/index.ts"
+    "test": "ts-node ./src/test/index.ts",
+    "format": "prettier --write \"./src/**/*.ts\""
   },
   "packageManager": "yarn@4.7.0+sha512.5a0afa1d4c1d844b3447ee3319633797bcd6385d9a44be07993ae52ff4facabccafb4af5dcd1c2f9a94ac113e5e9ff56f6130431905884414229e284e37bb7c9"
 }

src/index.ts

@@ -5,8 +5,8 @@ export {
   LoggedInjectable,
   LoggedGuard,
   LoggedInterceptor,
-} from "./logged";
+} from './logged';
-export { ScopedLogger } from "./logger";
+export { ScopedLogger } from './logger';
 export {
   InjectLogger,
   LoggedParam,
@@ -14,8 +14,6 @@ export {
   LoggedBody,
   LoggedQuery,
   Logged,
-  Returns
+  Returns,
-} from "./reflected";
+} from './reflected';
-export {
+export { getRequestLogger } from './utils';
-  getRequestLogger
-} from './utils'

src/internals/nest.ts

@@ -1,44 +1,52 @@
-import {RouteParamtypes} from '@nestjs/common/enums/route-paramtypes.enum';
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
-import {assignMetadata, ParamData, PipeTransform, RouteParamMetadata, Type} from "@nestjs/common";
+import {
-import {ROUTE_ARGS_METADATA} from '@nestjs/common/constants';
+  assignMetadata,
-import {isNil, isString} from "@nestjs/common/utils/shared.utils";
+  ParamData,
+  PipeTransform,
+  RouteParamMetadata,
+  Type,
+} from '@nestjs/common';
+import { ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
+import { isNil, isString } from '@nestjs/common/utils/shared.utils';
 
 export { RouteParamtypes, PipeTransform, Type, ROUTE_ARGS_METADATA };
 
 export function createRouteParamDecorator(paramtype: RouteParamtypes) {
   return (data?: ParamData): ParameterDecorator =>
     (target, key, index) => {
-      const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, target.constructor, key) || {};
+      const args =
+        Reflect.getMetadata(ROUTE_ARGS_METADATA, target.constructor, key) || {};
       Reflect.defineMetadata(
         ROUTE_ARGS_METADATA,
         assignMetadata<RouteParamtypes, Record<number, RouteParamMetadata>>(
-        args,
+          args,
-        paramtype,
+          paramtype,
-        index,
+          index,
-        data,
+          data,
         ),
         target.constructor,
         key,
       );
     };
-};
+}
-  
+
 export const createPipesRouteParamDecorator =
   (paramtype: RouteParamtypes) =>
-    (
+  (
-      data?: any,
+    data?: any,
-      ...pipes: (Type<PipeTransform> | PipeTransform)[]
+    ...pipes: (Type<PipeTransform> | PipeTransform)[]
-    ): ParameterDecorator =>
+  ): ParameterDecorator =>
-    (target, key, index) => {
+  (target, key, index) => {
-      const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, target.constructor, key) || {};
+    const args =
-      const hasParamData = isNil(data) || isString(data);
+      Reflect.getMetadata(ROUTE_ARGS_METADATA, target.constructor, key) || {};
-      const paramData = hasParamData ? data : undefined;
+    const hasParamData = isNil(data) || isString(data);
-      const paramPipes = hasParamData ? pipes : [data, ...pipes];
+    const paramData = hasParamData ? data : undefined;
-  
+    const paramPipes = hasParamData ? pipes : [data, ...pipes];
-      Reflect.defineMetadata(
+
-        ROUTE_ARGS_METADATA,
+    Reflect.defineMetadata(
-        assignMetadata(args, paramtype, index, paramData, ...paramPipes),
+      ROUTE_ARGS_METADATA,
-        target.constructor,
+      assignMetadata(args, paramtype, index, paramData, ...paramPipes),
-        key,
+      target.constructor,
-      );
+      key,
-    };
+    );
+  };

src/internals/utils.ts

@@ -1,48 +1,53 @@
-export const notIncludedSymbol = Symbol("notIncluded");
+export const notIncludedSymbol = Symbol('notIncluded');
 
 export function includeObjectSync(
   ocv: any,
   opt: {
-    paths: string[],
+    paths: string[];
-  }
+  },
 ) {
-  let current = Array.isArray(ocv) ? [] : typeof ocv === 'object' ? {} : ocv
+  let current = Array.isArray(ocv) ? [] : typeof ocv === 'object' ? {} : ocv;
   opt.paths.forEach((dotpath) => {
     let query = ocv;
     let objRef = current;
     const path = dotpath.split('.');
     for (const [index, key] of Object.entries(path)) {
-      query = query[key]
+      query = query[key];
       if (query !== undefined && objRef[key] === undefined) {
         if (typeof query === 'object') {
           if (Array.isArray(query)) {
-            objRef[key] = []
+            objRef[key] = [];
           } else {
-            objRef[key] = {}
+            objRef[key] = {};
           }
         }
       }
       if (typeof query !== 'object' || index === (path.length - 1).toString()) {
         objRef[key] = query;
-        break
+        break;
       }
-      objRef = objRef[key]
+      objRef = objRef[key];
     }
-  })
+  });
   return current;
 }
 
 export function excludeObjectSync(
   ocv: any,
   opt: {
-    paths: string[]
+    paths: string[];
-  }
+  },
 ) {
-  const copied = typeof ocv === 'object' ? Array.isArray(ocv) ? [...ocv] : { ...ocv } : ocv;
+  const copied =
+    typeof ocv === 'object'
+      ? Array.isArray(ocv)
+        ? [...ocv]
+        : { ...ocv }
+      : ocv;
   opt.paths.forEach((dotpath) => {
     let objRef = copied;
-    const path = dotpath.split('.')
+    const path = dotpath.split('.');
-    const lastIndex = (path.length - 1).toString()
+    const lastIndex = (path.length - 1).toString();
     for (const [index, key] of Object.entries(path)) {
       if (index === lastIndex) {
         delete objRef[key];
@@ -53,9 +58,9 @@ export function excludeObjectSync(
         break;
       }
     }
-  })
+  });
 
-  return copied
+  return copied;
 }
 
 export function objectContainedLogSync(
@@ -63,34 +68,30 @@ export function objectContainedLogSync(
   options?: {
     include?: string[];
     exclude?: string[];
-  }
+  },
 ): string {
   if (options && typeof ocv === 'object' && ocv !== null) {
     if (options.include && options.include.length > 0) {
-      return JSON.stringify(
+      return JSON.stringify(includeObjectSync(ocv, { paths: options.include }));
-        includeObjectSync(ocv, { paths: options.include })
-      );
     }
     if (options.exclude && options.exclude.length > 0) {
-      return JSON.stringify(
+      return JSON.stringify(excludeObjectSync(ocv, { paths: options.exclude }));
-        excludeObjectSync(ocv, { paths: options.exclude })
-      )
     }
   }
 
-  if (typeof ocv === "object" && ocv !== null) {
+  if (typeof ocv === 'object' && ocv !== null) {
     return JSON.stringify(ocv);
   } else {
-    return `${ocv}`
+    return `${ocv}`;
   }
 }
 
 export function getItemByPathSync(obj: object, path: string | string[]) {
-  const paths = Array.isArray(path) ? path : path.split(".");
+  const paths = Array.isArray(path) ? path : path.split('.');
 
   return Object.keys(obj).includes(paths[0])
-    ? typeof obj[paths[0]] === "object"
+    ? typeof obj[paths[0]] === 'object'
       ? getItemByPathSync(obj[paths[0]], paths.slice(1))
       : obj[paths[0]]
     : undefined;
-}
+}

src/logged/class.ts

@@ -3,30 +3,24 @@ import {
   Controller,
   ControllerOptions,
   ScopeOptions,
-} from "@nestjs/common";
+} from '@nestjs/common';
-import {
+import { loggerInit, RevRequestMethod } from './utils';
-  loggerInit,
+import { LoggedRoute, LoggedFunction } from './methods';
-  RevRequestMethod
-} from './utils';
-import {
-  LoggedRoute,
-  LoggedFunction
-} from "./methods";
 
 export function LoggedInjectable(
-  options?: ScopeOptions & { verbose?: boolean }
+  options?: ScopeOptions & { verbose?: boolean },
 ) {
   return (target: any) => {
     loggerInit(target.prototype);
-  
+
     const logger = target.prototype.logger;
-  
+
     const methods = Object.getOwnPropertyNames(target.prototype);
-  
+
     methods.forEach((method) => {
       if (
-        method !== "constructor" &&
+        method !== 'constructor' &&
-        typeof target.prototype[method] === "function"
+        typeof target.prototype[method] === 'function'
       ) {
         if (options && options.verbose)
           logger.log(`LoggedFunction applied to ${method}`);
@@ -39,49 +33,49 @@ export function LoggedInjectable(
     Injectable(options)(target);
   };
 }
-  
+
-  export function LoggedController(): (target: any) => void;
+export function LoggedController(): (target: any) => void;
-  export function LoggedController(
+export function LoggedController(
-    prefix: string | string[]
+  prefix: string | string[],
-  ): (target: any) => void;
+): (target: any) => void;
-  export function LoggedController(
+export function LoggedController(
-    options: ControllerOptions & { verbose?: boolean }
+  options: ControllerOptions & { verbose?: boolean },
-  ): (target: any) => void;
+): (target: any) => void;
-  
+
-  export function LoggedController(param?: any): (target: any) => void {
+export function LoggedController(param?: any): (target: any) => void {
-    return (target: any) => {
+  return (target: any) => {
-      loggerInit(target.prototype);
+    loggerInit(target.prototype);
-  
+
-      const logger = target.prototype.logger;
+    const logger = target.prototype.logger;
-  
+
-      const methods = Object.getOwnPropertyNames(target.prototype);
+    const methods = Object.getOwnPropertyNames(target.prototype);
-  
+
-      let verbose =
+    let verbose =
-        typeof param === "object" && Object.keys(param).includes("verbose")
+      typeof param === 'object' && Object.keys(param).includes('verbose')
-          ? param.verbose
+        ? param.verbose
-          : false;
+        : false;
-  
+
-      methods.forEach((method) => {
+    methods.forEach((method) => {
-        if (
+      if (
-          method !== "constructor" &&
+        method !== 'constructor' &&
-          typeof target.prototype[method] === "function"
+        typeof target.prototype[method] === 'function'
-        ) {
+      ) {
-          if (verbose) {
+        if (verbose) {
-            const path = Reflect.getMetadata("path", target.prototype[method]);
+          const path = Reflect.getMetadata('path', target.prototype[method]);
-            const httpMethod = Reflect.getMetadata(
+          const httpMethod = Reflect.getMetadata(
-              "method",
+            'method',
-              target.prototype[method]
+            target.prototype[method],
-            );
+          );
-            logger.log(
+          logger.log(
-              `LoggedRoute applied to ${method} (${RevRequestMethod[httpMethod]} ${path})`
+            `LoggedRoute applied to ${method} (${RevRequestMethod[httpMethod]} ${path})`,
-            );
+          );
-          }
-          LoggedRoute()(target.prototype, method, {
-            value: target.prototype[method],
-          });
         }
-      });
+        LoggedRoute()(target.prototype, method, {
-  
+          value: target.prototype[method],
-      Controller(param)(target);
+        });
-    };
+      }
-  }
+    });
+
+    Controller(param)(target);
+  };
+}

src/logged/index.ts

@@ -1,2 +1,2 @@
-export * from "./methods";
+export * from './methods';
-export { LoggedController, LoggedInjectable } from "./class"
+export { LoggedController, LoggedInjectable } from './class';

src/logged/metadata.ts

@@ -1,21 +1,21 @@
 import { OverrideBuildOptions, defaultOverrideBuildOptions } from './utils';
 
-export const nestLoggedMetadata = Symbol("nlogdec-metadata");
+export const nestLoggedMetadata = Symbol('nlogdec-metadata');
 
 export class LoggedMetadata {
-  options: OverrideBuildOptions
+  options: OverrideBuildOptions;
 
   constructor(options?: Partial<OverrideBuildOptions>) {
     this.options = {
       ...defaultOverrideBuildOptions,
       ...(options ?? {}),
-    }
+    };
   }
 
   updateOption(options: Partial<OverrideBuildOptions>) {
     this.options = {
       ...this.options,
-      ...options
+      ...options,
-    }
+    };
   }
-}
+}

src/logged/methods/function.ts

@@ -1,16 +1,22 @@
-import { Logger } from "@nestjs/common";
+import { Logger } from '@nestjs/common';
-import { OverrideBuildOptions, loggerInit } from "../utils";
+import { OverrideBuildOptions, loggerInit } from '../utils';
-import { LoggedMetadata, nestLoggedMetadata } from "../metadata";
+import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
-import { loggedParam, scopedLogger, returns, ReturnsReflectData, LoggedParamReflectData } from "../../reflected";
+import {
-import { overrideBuild } from "../override";
+  loggedParam,
+  scopedLogger,
+  returns,
+  ReturnsReflectData,
+  LoggedParamReflectData,
+} from '../../reflected';
+import { overrideBuild } from '../override';
 
 export function LoggedFunction<F extends Array<any>, R>(
-  options?: Partial<OverrideBuildOptions>
+  options?: Partial<OverrideBuildOptions>,
 ) {
   return (
     _target: any,
     key: string,
-    descriptor: TypedPropertyDescriptor<(...args: F) => R | Promise<R>>
+    descriptor: TypedPropertyDescriptor<(...args: F) => R | Promise<R>>,
   ) => {
     loggerInit(_target);
 
@@ -18,9 +24,9 @@ export function LoggedFunction<F extends Array<any>, R>(
 
     const fn = descriptor.value;
 
-    if (!fn || typeof fn !== "function") {
+    if (!fn || typeof fn !== 'function') {
       logger.warn(
-        `LoggedFunction decorator applied to non-function property: ${key}`
+        `LoggedFunction decorator applied to non-function property: ${key}`,
       );
       return;
     }
@@ -28,12 +34,12 @@ export function LoggedFunction<F extends Array<any>, R>(
     const logMetadata: LoggedMetadata | undefined = Reflect.getOwnMetadata(
       nestLoggedMetadata,
       _target,
-      key
+      key,
-    )
+    );
     if (logMetadata) {
       // already applied, override instead
-      logMetadata.updateOption(options)
+      logMetadata.updateOption(options);
-      return
+      return;
     }
     const newMetadata = new LoggedMetadata(options);
 
@@ -45,18 +51,18 @@ export function LoggedFunction<F extends Array<any>, R>(
     const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
       scopedLogger,
       _target,
-      key
+      key,
     );
 
     const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
       loggedParam,
       _target,
-      key
+      key,
     );
 
     const returnsData: ReturnsReflectData[] | true = Reflect.getOwnMetadata(
       returns,
-      fn
+      fn,
     );
 
     const overrideFunction = overrideBuild(
@@ -75,15 +81,10 @@ export function LoggedFunction<F extends Array<any>, R>(
     _target[key] = overrideFunction;
     descriptor.value = overrideFunction;
 
-    Reflect.defineMetadata(
+    Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
-      nestLoggedMetadata,
-      newMetadata,
-      _target,
-      key
-    )
     all.forEach(([k, v]) => {
       Reflect.defineMetadata(k, v, _target[key]);
       Reflect.defineMetadata(k, v, descriptor.value);
     });
-  }
+  };
-}
+}

src/logged/methods/guard.ts

@@ -1,14 +1,18 @@
-import { ExecutionContext, Logger } from "@nestjs/common";
+import { ExecutionContext, Logger } from '@nestjs/common';
-import { OverrideBuildOptions, loggerInit } from "../utils";
+import { OverrideBuildOptions, loggerInit } from '../utils';
-import { LoggedMetadata, nestLoggedMetadata } from "../metadata";
+import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
-import { scopedLogger, returns, ReturnsReflectData } from "../../reflected";
+import { scopedLogger, returns, ReturnsReflectData } from '../../reflected';
-import { overrideBuild } from "../override";
+import { overrideBuild } from '../override';
 
-export function LoggedGuard<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>) {
+export function LoggedGuard<F extends Array<any>, R>(
+  options?: Partial<OverrideBuildOptions>,
+) {
   return (
     _target: any,
     key: string,
-    descriptor: TypedPropertyDescriptor<(context: ExecutionContext, ...args: F) => R>
+    descriptor: TypedPropertyDescriptor<
+      (context: ExecutionContext, ...args: F) => R
+    >,
   ) => {
     loggerInit(_target);
 
@@ -16,9 +20,9 @@ export function LoggedGuard<F extends Array<any>, R>(options?: Partial<OverrideB
 
     const fn = descriptor.value;
 
-    if (!fn || typeof fn!== "function") {
+    if (!fn || typeof fn !== 'function') {
       logger.warn(
-        `LoggedGuard decorator applied to non-function property: ${key}`
+        `LoggedGuard decorator applied to non-function property: ${key}`,
       );
       return;
     }
@@ -26,12 +30,12 @@ export function LoggedGuard<F extends Array<any>, R>(options?: Partial<OverrideB
     const logMetadata: LoggedMetadata | undefined = Reflect.getOwnMetadata(
       nestLoggedMetadata,
       _target,
-      key
+      key,
-    )
+    );
     if (logMetadata) {
       // already applied, override instead
-      logMetadata.updateOption(options)
+      logMetadata.updateOption(options);
-      return
+      return;
     }
     const newMetadata = new LoggedMetadata(options);
 
@@ -43,12 +47,12 @@ export function LoggedGuard<F extends Array<any>, R>(options?: Partial<OverrideB
     const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
       scopedLogger,
       _target,
-      key
+      key,
     );
 
     const returnsData: ReturnsReflectData[] | true = Reflect.getOwnMetadata(
       returns,
-      fn
+      fn,
     );
 
     const overrideFunction = overrideBuild(
@@ -67,15 +71,10 @@ export function LoggedGuard<F extends Array<any>, R>(options?: Partial<OverrideB
     _target[key] = overrideFunction;
     descriptor.value = overrideFunction;
 
-    Reflect.defineMetadata(
+    Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
-      nestLoggedMetadata,
-      newMetadata,
-      _target,
-      key
-    )
     all.forEach(([k, v]) => {
       Reflect.defineMetadata(k, v, _target[key]);
       Reflect.defineMetadata(k, v, descriptor.value);
     });
-  }
+  };
-}
+}

src/logged/methods/index.ts

@@ -1,5 +1,5 @@
-export { LoggedFunction } from "./function";
+export { LoggedFunction } from './function';
-export { LoggedRoute } from "./route";
+export { LoggedRoute } from './route';
-export { LoggedGuard } from "./guard";
+export { LoggedGuard } from './guard';
-export { LoggedInterceptor } from "./interceptor";
+export { LoggedInterceptor } from './interceptor';
-export { LoggedMiddleware } from "./middleware";
+export { LoggedMiddleware } from './middleware';

src/logged/methods/interceptor.ts

@@ -1,15 +1,19 @@
-import { OverrideBuildOptions } from "../utils";
+import { OverrideBuildOptions } from '../utils';
-import { ExecutionContext, Logger } from "@nestjs/common";
+import { ExecutionContext, Logger } from '@nestjs/common';
-import { loggerInit } from "../utils";
+import { loggerInit } from '../utils';
 import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
-import { scopedLogger, returns, ReturnsReflectData } from "../../reflected";
+import { scopedLogger, returns, ReturnsReflectData } from '../../reflected';
-import { overrideBuild } from "../override";
+import { overrideBuild } from '../override';
 
-export function LoggedInterceptor<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>) {
+export function LoggedInterceptor<F extends Array<any>, R>(
+  options?: Partial<OverrideBuildOptions>,
+) {
   return (
     _target: any,
     key: string,
-    descriptor: TypedPropertyDescriptor<(context: ExecutionContext, ...args: F) => R>
+    descriptor: TypedPropertyDescriptor<
+      (context: ExecutionContext, ...args: F) => R
+    >,
   ) => {
     loggerInit(_target);
 
@@ -17,9 +21,9 @@ export function LoggedInterceptor<F extends Array<any>, R>(options?: Partial<Ove
 
     const fn = descriptor.value;
 
-    if (!fn || typeof fn!== "function") {
+    if (!fn || typeof fn !== 'function') {
       logger.warn(
-        `LoggedInterceptor decorator applied to non-function property: ${key}`
+        `LoggedInterceptor decorator applied to non-function property: ${key}`,
       );
       return;
     }
@@ -27,12 +31,12 @@ export function LoggedInterceptor<F extends Array<any>, R>(options?: Partial<Ove
     const logMetadata: LoggedMetadata | undefined = Reflect.getOwnMetadata(
       nestLoggedMetadata,
       _target,
-      key
+      key,
-    )
+    );
     if (logMetadata) {
       // already applied, override instead
-      logMetadata.updateOption(options)
+      logMetadata.updateOption(options);
-      return
+      return;
     }
     const newMetadata = new LoggedMetadata(options);
 
@@ -44,12 +48,12 @@ export function LoggedInterceptor<F extends Array<any>, R>(options?: Partial<Ove
     const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
       scopedLogger,
       _target,
-      key
+      key,
     );
 
     const returnsData: ReturnsReflectData[] | true = Reflect.getOwnMetadata(
       returns,
-      fn
+      fn,
     );
 
     const overrideFunction = overrideBuild(
@@ -68,15 +72,10 @@ export function LoggedInterceptor<F extends Array<any>, R>(options?: Partial<Ove
     _target[key] = overrideFunction;
     descriptor.value = overrideFunction;
 
-    Reflect.defineMetadata(
+    Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
-      nestLoggedMetadata,
-      newMetadata,
-      _target,
-      key
-    )
     all.forEach(([k, v]) => {
       Reflect.defineMetadata(k, v, _target[key]);
       Reflect.defineMetadata(k, v, descriptor.value);
     });
-  }
+  };
-}
+}

src/logged/methods/middleware.ts

@@ -1,15 +1,19 @@
-import { OverrideBuildOptions } from "../utils";
+import { OverrideBuildOptions } from '../utils';
-import { ExecutionContext, Logger } from "@nestjs/common";
+import { ExecutionContext, Logger } from '@nestjs/common';
-import { loggerInit } from "../utils";
+import { loggerInit } from '../utils';
 import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
-import { scopedLogger, returns, ReturnsReflectData } from "../../reflected";
+import { scopedLogger, returns, ReturnsReflectData } from '../../reflected';
-import { overrideBuild } from "../override";
+import { overrideBuild } from '../override';
 
-export function LoggedMiddleware<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>) {
+export function LoggedMiddleware<F extends Array<any>, R>(
+  options?: Partial<OverrideBuildOptions>,
+) {
   return (
     _target: any,
     key: string,
-    descriptor: TypedPropertyDescriptor<(context: ExecutionContext, ...args: F) => R>
+    descriptor: TypedPropertyDescriptor<
+      (context: ExecutionContext, ...args: F) => R
+    >,
   ) => {
     loggerInit(_target);
 
@@ -17,9 +21,9 @@ export function LoggedMiddleware<F extends Array<any>, R>(options?: Partial<Over
 
     const fn = descriptor.value;
 
-    if (!fn || typeof fn!== "function") {
+    if (!fn || typeof fn !== 'function') {
       logger.warn(
-        `LoggedMiddleware decorator applied to non-function property: ${key}`
+        `LoggedMiddleware decorator applied to non-function property: ${key}`,
       );
       return;
     }
@@ -27,12 +31,12 @@ export function LoggedMiddleware<F extends Array<any>, R>(options?: Partial<Over
     const logMetadata: LoggedMetadata | undefined = Reflect.getOwnMetadata(
       nestLoggedMetadata,
       _target,
-      key
+      key,
-    )
+    );
     if (logMetadata) {
       // already applied, override instead
-      logMetadata.updateOption(options)
+      logMetadata.updateOption(options);
-      return
+      return;
     }
     const newMetadata = new LoggedMetadata(options);
 
@@ -44,12 +48,12 @@ export function LoggedMiddleware<F extends Array<any>, R>(options?: Partial<Over
     const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
       scopedLogger,
       _target,
-      key
+      key,
     );
 
     const returnsData: ReturnsReflectData[] | true = Reflect.getOwnMetadata(
       returns,
-      fn
+      fn,
     );
 
     const overrideFunction = overrideBuild(
@@ -68,15 +72,10 @@ export function LoggedMiddleware<F extends Array<any>, R>(options?: Partial<Over
     _target[key] = overrideFunction;
     descriptor.value = overrideFunction;
 
-    Reflect.defineMetadata(
+    Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
-      nestLoggedMetadata,
-      newMetadata,
-      _target,
-      key
-    )
     all.forEach(([k, v]) => {
       Reflect.defineMetadata(k, v, _target[key]);
       Reflect.defineMetadata(k, v, descriptor.value);
     });
-  }
+  };
-}
+}

src/logged/methods/route.ts

@@ -1,15 +1,24 @@
-import { RequestMethod } from "@nestjs/common";
+import { RequestMethod } from '@nestjs/common';
-import { OverrideBuildOptions, loggerInit, RevRequestMethod } from "../utils";
+import { OverrideBuildOptions, loggerInit, RevRequestMethod } from '../utils';
-import { LoggedMetadata, nestLoggedMetadata } from "../metadata";
+import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
-import { loggedParam, scopedLogger, returns, ReturnsReflectData, LoggedParamReflectData } from "../../reflected";
+import {
-import { overrideBuild } from "../override";
+  loggedParam,
-import { createRouteParamDecorator } from "../../internals/nest";
+  scopedLogger,
+  returns,
+  ReturnsReflectData,
+  LoggedParamReflectData,
+} from '../../reflected';
+import { overrideBuild } from '../override';
+import { createRouteParamDecorator } from '../../internals/nest';
 
-export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: Partial<OverrideBuildOptions>) {
+export function LoggedRoute<F extends Array<any>, R>(
+  route?: string,
+  options?: Partial<OverrideBuildOptions>,
+) {
   return (
     _target: any,
     key: string,
-    descriptor: TypedPropertyDescriptor<(...args: F) => R>
+    descriptor: TypedPropertyDescriptor<(...args: F) => R>,
   ) => {
     loggerInit(_target);
 
@@ -17,9 +26,9 @@ export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: P
 
     const fn = descriptor.value;
 
-    if (!fn || typeof fn !== "function") {
+    if (!fn || typeof fn !== 'function') {
       logger.warn(
-        `LoggedRoute decorator applied to non-function property: ${key}`
+        `LoggedRoute decorator applied to non-function property: ${key}`,
       );
       return;
     }
@@ -27,12 +36,12 @@ export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: P
     const logMetadata: LoggedMetadata | undefined = Reflect.getOwnMetadata(
       nestLoggedMetadata,
       _target,
-      key
+      key,
-    )
+    );
     if (logMetadata) {
       // already applied, override instead
-      logMetadata.updateOption(options)
+      logMetadata.updateOption(options);
-      return
+      return;
     }
     const newMetadata = new LoggedMetadata(options);
 
@@ -41,16 +50,17 @@ export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: P
       Reflect.getMetadata(k, fn),
     ]);
 
-    const httpPath: string = Reflect.getMetadata("path", fn);
+    const httpPath: string = Reflect.getMetadata('path', fn);
-    const httpMethod: RequestMethod = Reflect.getMetadata("method", fn);
+    const httpMethod: RequestMethod = Reflect.getMetadata('method', fn);
 
-    const fullRoute = `${_target.constructor.name}::${route ?? httpPath}[${RevRequestMethod[httpMethod]
+    const fullRoute = `${_target.constructor.name}::${route ?? httpPath}[${
-      }]`;
+      RevRequestMethod[httpMethod]
+    }]`;
 
     const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
       scopedLogger,
       _target,
-      key
+      key,
     );
     // if @InjectLogger exists, fake nestjs as it is @Req()
     if (scopedLoggerInjectableParam !== undefined) {
@@ -60,12 +70,12 @@ export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: P
     const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
       loggedParam,
       _target,
-      key
+      key,
     );
 
     const returnsData: ReturnsReflectData[] | true = Reflect.getOwnMetadata(
       returns,
-      fn
+      fn,
     );
 
     const overrideFunction = overrideBuild(
@@ -85,15 +95,10 @@ export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: P
     _target[key] = overrideFunction;
     descriptor.value = overrideFunction;
 
-    Reflect.defineMetadata(
+    Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
-      nestLoggedMetadata,
-      newMetadata,
-      _target,
-      key
-    )
     all.forEach(([k, v]) => {
       Reflect.defineMetadata(k, v, _target[key]);
       Reflect.defineMetadata(k, v, descriptor.value);
     });
   };
-}
+}

src/logged/override.ts

@@ -1,9 +1,13 @@
-import { Logger, ExecutionContext } from "@nestjs/common";
+import { Logger, ExecutionContext } from '@nestjs/common';
-import { LoggedParamReflectData, ReturnsReflectData } from "../reflected";
+import { LoggedParamReflectData, ReturnsReflectData } from '../reflected';
 import { LoggedMetadata } from './metadata';
-import { BuildType, REQUEST_LOG_ID, createCallLogIdentifyMessage } from "./utils";
+import {
-import { objectContainedLogSync, getItemByPathSync } from "../internals/utils";
+  BuildType,
-import { ScopedLogger } from "../logger";
+  REQUEST_LOG_ID,
+  createCallLogIdentifyMessage,
+} from './utils';
+import { objectContainedLogSync, getItemByPathSync } from '../internals/utils';
+import { ScopedLogger } from '../logger';
 
 interface FunctionMetadata {
   scopedLoggerInjectableParam?: number;
@@ -42,43 +46,64 @@ export function overrideBuild<F extends Array<any>, R>(
   return function (...args: F): R {
     // Creating ScopedLogger
     let injectedLogger: Logger = baseLogger;
-    if (typeof metadatas.scopedLoggerInjectableParam !== "undefined") {
+    if (typeof metadatas.scopedLoggerInjectableParam !== 'undefined') {
       if (type === 'function') {
         if (
           args.length <= metadatas.scopedLoggerInjectableParam ||
           !(args[metadatas.scopedLoggerInjectableParam] instanceof ScopedLogger)
         ) {
-          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key);
+          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(
+            baseLogger,
+            key,
+          );
         } else {
-          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromSuper(baseLogger, args[metadatas.scopedLoggerInjectableParam], key);
+          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromSuper(
+            baseLogger,
+            args[metadatas.scopedLoggerInjectableParam],
+            key,
+          );
         }
       } else {
         // special, can access to request object
         if (type === 'guard' || type === 'interceptor') {
           // args[0] == ExecutionContext
-          const ctx = (args[0] as ExecutionContext);
+          const ctx = args[0] as ExecutionContext;
           if (ctx.getType() !== 'http') {
-            injectedLogger.error('Cannot inject logger: Request type is not http');
+            injectedLogger.error(
+              'Cannot inject logger: Request type is not http',
+            );
           } else {
             let req = ctx.switchToHttp().getRequest();
             if (req[REQUEST_LOG_ID] === undefined) {
               req[REQUEST_LOG_ID] = ScopedLogger.createScopeId();
             }
-            args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
+            args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(
+              baseLogger,
+              key,
+              req[REQUEST_LOG_ID],
+            );
           }
         } else if (type === 'middleware') {
           let req = args[0];
           if (req[REQUEST_LOG_ID] === undefined) {
             req[REQUEST_LOG_ID] = ScopedLogger.createScopeId();
           }
-          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
+          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(
+            baseLogger,
+            key,
+            req[REQUEST_LOG_ID],
+          );
         } else if (type === 'route') {
           // args[metadatas.scopedLoggerInjectableParam] is now Request object, thanks to code in @LoggedRoute!!!!
           let req = args[metadatas.scopedLoggerInjectableParam];
           if (req[REQUEST_LOG_ID] === undefined) {
             req[REQUEST_LOG_ID] = ScopedLogger.createScopeId();
           }
-          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
+          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(
+            baseLogger,
+            key,
+            req[REQUEST_LOG_ID],
+          );
         }
       }
 
@@ -96,24 +121,30 @@ export function overrideBuild<F extends Array<any>, R>(
 
     // Start Log
     if (logged.options.callLogLevel !== 'skip') {
-      const callLogIdentifyMessage = 
+      const callLogIdentifyMessage =
-        type === 'middleware' || type === 'guard' || type === 'interceptor' || type === 'route'
+        type === 'middleware' ||
+        type === 'guard' ||
+        type === 'interceptor' ||
+        type === 'route'
           ? createCallLogIdentifyMessage('HIT', type, key, route)
           : createCallLogIdentifyMessage('HIT', type, key);
       injectedLogger[logged.options.callLogLevel](
-        `${callLogIdentifyMessage} ${metadatas.loggedParams && metadatas.loggedParams.length > 0
+        `${callLogIdentifyMessage} ${
-          ? "WITH " +
+          metadatas.loggedParams && metadatas.loggedParams.length > 0
-          metadatas.loggedParams.map(
+            ? 'WITH ' +
-            ({ name, index, include, exclude }) =>
+              metadatas.loggedParams
-              name +
+                .map(
-              "=" +
+                  ({ name, index, include, exclude }) =>
-              objectContainedLogSync(args[index], {
+                    name +
-                include,
+                    '=' +
-                exclude,
+                    objectContainedLogSync(args[index], {
-              })
+                      include,
-          ).join(", ")
+                      exclude,
-          : ""
+                    }),
-        }`
+                )
+                .join(', ')
+            : ''
+        }`,
       );
     }
 
@@ -128,48 +159,58 @@ export function overrideBuild<F extends Array<any>, R>(
         ) {
           return r['then']((r: any) => {
             const resultLogged = Array.isArray(returnsData)
-              ? typeof r === "object" && r !== null
+              ? typeof r === 'object' && r !== null
-                ? "WITH " +
+                ? 'WITH ' +
-                returnsData.map(({ name, path }) => {
+                  returnsData
-                  const value = getItemByPathSync(r, path);
+                    .map(({ name, path }) => {
+                      const value = getItemByPathSync(r, path);
 
-                  return value !== undefined ? `${name}=${value}` : "";
+                      return value !== undefined ? `${name}=${value}` : '';
-                })
+                    })
-                  .filter((v) => v.length > 0)
+                    .filter((v) => v.length > 0)
-                  .join(", ")
+                    .join(', ')
-                : ""
+                : ''
               : typeof returnsData === 'string'
-                ? "WITH " + returnsData + "=" + typeof r === "object" ? JSON.stringify(r) : r
+                ? 'WITH ' + returnsData + '=' + typeof r === 'object'
+                  ? JSON.stringify(r)
+                  : r
                 : returnsData
-                  ? typeof r === "object"
+                  ? typeof r === 'object'
-                    ? "WITH " + JSON.stringify(r)
+                    ? 'WITH ' + JSON.stringify(r)
-                    : "WITH " + r
+                    : 'WITH ' + r
-                  : "";
+                  : '';
 
-            injectedLogger[logged.options.returnLogLevel](`${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`);
+            injectedLogger[logged.options.returnLogLevel](
+              `${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`,
+            );
             return r;
-          })
+          });
         } else {
           const resultLogged = Array.isArray(returnsData)
-            ? typeof r === "object" && r !== null
+            ? typeof r === 'object' && r !== null
-              ? "WITH " +
+              ? 'WITH ' +
-              returnsData.map(({ name, path }) => {
+                returnsData
-                const value = getItemByPathSync(r, path);
+                  .map(({ name, path }) => {
+                    const value = getItemByPathSync(r, path);
 
-                return value !== undefined ? `${name}=${value}` : "";
+                    return value !== undefined ? `${name}=${value}` : '';
-              })
+                  })
-                .filter((v) => v.length > 0)
+                  .filter((v) => v.length > 0)
-                .join(", ")
+                  .join(', ')
-              : ""
+              : ''
             : typeof returnsData === 'string'
-              ? "WITH " + returnsData + "=" + typeof r === "object" ? JSON.stringify(r) : r
+              ? 'WITH ' + returnsData + '=' + typeof r === 'object'
+                ? JSON.stringify(r)
+                : r
               : returnsData
-                ? typeof r === "object"
+                ? typeof r === 'object'
-                  ? "WITH " + JSON.stringify(r)
+                  ? 'WITH ' + JSON.stringify(r)
-                  : "WITH " + r
+                  : 'WITH ' + r
-                : "";
+                : '';
 
-          injectedLogger[logged.options.returnLogLevel](`${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`);
+          injectedLogger[logged.options.returnLogLevel](
+            `${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`,
+          );
           return r;
         }
       } else {
@@ -178,9 +219,11 @@ export function overrideBuild<F extends Array<any>, R>(
     } catch (e) {
       // Error Log
       if (logged.options.errorLogLevel !== 'skip') {
-        injectedLogger[logged.options.errorLogLevel](`${createCallLogIdentifyMessage('ERROR', type, key, route)} ${e}`);
+        injectedLogger[logged.options.errorLogLevel](
+          `${createCallLogIdentifyMessage('ERROR', type, key, route)} ${e}`,
+        );
       }
       throw e;
     }
-  }
+  };
-}
+}

src/logged/utils.ts

@@ -1,22 +1,22 @@
-import { Logger, LogLevel } from "@nestjs/common";
+import { Logger, LogLevel } from '@nestjs/common';
 
 export const RevRequestMethod = [
-  "GET",
+  'GET',
-  "POST",
+  'POST',
-  "PUT",
+  'PUT',
-  "DELETE",
+  'DELETE',
-  "PATCH",
+  'PATCH',
-  "ALL",
+  'ALL',
-  "OPTIONS",
+  'OPTIONS',
-  "HEAD",
+  'HEAD',
-  "SEARCH",
+  'SEARCH',
 ];
 
 export 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,
@@ -25,7 +25,12 @@ export function loggerInit(_target: any) {
   }
 }
 
-export type BuildType = 'route' | 'function' | 'guard' | 'interceptor' | 'middleware';
+export type BuildType =
+  | 'route'
+  | 'function'
+  | 'guard'
+  | 'interceptor'
+  | 'middleware';
 
 const callLogIdentifyMessageDictionary: Record<BuildType, string> = {
   route: 'ENDPOINT',
@@ -33,14 +38,24 @@ const callLogIdentifyMessageDictionary: Record<BuildType, string> = {
   guard: 'GUARD',
   interceptor: 'INTERCEPTOR',
   middleware: 'MIDDLEWARE',
-}
+};
 
-export function createCallLogIdentifyMessage(message: 'HIT' | 'RETURNED' | 'ERROR', type: BuildType, key?: string, route?: string) {
+export function createCallLogIdentifyMessage(
+  message: 'HIT' | 'RETURNED' | 'ERROR',
+  type: BuildType,
+  key?: string,
+  route?: string,
+) {
   if (message === 'ERROR')
     return `ERROR WHILE ${callLogIdentifyMessageDictionary[type]} ${key} (${route}): `;
 
-  if (type === 'guard' || type === 'interceptor' || type === 'middleware' || type === 'route')
+  if (
-    return `${message} ${callLogIdentifyMessageDictionary[type]} ${key} (${route})`
+    type === 'guard' ||
+    type === 'interceptor' ||
+    type === 'middleware' ||
+    type === 'route'
+  )
+    return `${message} ${callLogIdentifyMessageDictionary[type]} ${key} (${route})`;
   if (type === 'function')
     return `${message} ${callLogIdentifyMessageDictionary[type]} ${key}`;
 
@@ -68,4 +83,4 @@ export const defaultOverrideBuildOptions: OverrideBuildOptions = {
   skipCallLog: false,
   skipReturnLog: false,
   skipErrorLog: false,
-}
+};

src/logger.ts

@@ -1,7 +1,7 @@
-import { Logger, LogLevel } from "@nestjs/common";
+import { Logger, LogLevel } from '@nestjs/common';
 import * as hyperid from 'hyperid';
 
-const createId = hyperid({ fixedLength: true })
+const createId = hyperid({ fixedLength: true });
 
 export class ScopedLogger extends Logger {
   constructor(
@@ -15,30 +15,39 @@ export class ScopedLogger extends Logger {
   private scopedLog(method: LogLevel) {
     return (message: string) => {
       this.logger[method](
-        `${this.scopeId ? `(ID ${this.scopeId}) | ` : ""
+        `${
-        }${this.scope.join(" -> ")}: ${message}`
+          this.scopeId ? `(ID ${this.scopeId}) | ` : ''
+        }${this.scope.join(' -> ')}: ${message}`,
       );
     };
   }
 
-  debug = this.scopedLog("debug");
+  debug = this.scopedLog('debug');
-  log = this.scopedLog("log");
+  log = this.scopedLog('log');
-  warn = this.scopedLog("warn");
+  warn = this.scopedLog('warn');
-  verbose = this.scopedLog("verbose");
+  verbose = this.scopedLog('verbose');
-  error = this.scopedLog("error");
+  error = this.scopedLog('error');
-  fatal = this.scopedLog("fatal");
+  fatal = this.scopedLog('fatal');
 
-  static fromSuper(baseLogger: Logger, logger: ScopedLogger, scope: string): ScopedLogger {
+  static fromSuper(
+    baseLogger: Logger,
+    logger: ScopedLogger,
+    scope: string,
+  ): ScopedLogger {
     return new ScopedLogger(
-      baseLogger, [...logger.scope, scope], logger.scopeId
+      baseLogger,
-    )
+      [...logger.scope, scope],
-  };
+      logger.scopeId,
-  static fromRoot(logger: Logger, scope: string, scopeId?: string): ScopedLogger {
+    );
-    return new ScopedLogger(
+  }
-      logger, [scope], scopeId
+  static fromRoot(
-    )
+    logger: Logger,
-  };
+    scope: string,
+    scopeId?: string,
+  ): ScopedLogger {
+    return new ScopedLogger(logger, [scope], scopeId);
+  }
   static createScopeId(): string {
     return createId();
   }
-}
+}

src/reflected.ts

@@ -1,4 +1,10 @@
-import { RouteParamtypes, Type, PipeTransform, createPipesRouteParamDecorator, createRouteParamDecorator } from "./internals/nest";
+import {
+  RouteParamtypes,
+  Type,
+  PipeTransform,
+  createPipesRouteParamDecorator,
+  createRouteParamDecorator,
+} from './internals/nest';
 
 export type Path = string | string[];
 export type Paths = Path[];
@@ -27,28 +33,32 @@ export interface ReturnsReflectData {
   path: string;
 }
 
-export const scopedLogger = Symbol("nlogdec-scopedLogger");
+export const scopedLogger = Symbol('nlogdec-scopedLogger');
-export const loggedParam = Symbol("nlogdec-loggedParam");
+export const loggedParam = Symbol('nlogdec-loggedParam');
-export const returns = Symbol("nlogdec-returns");
+export const returns = Symbol('nlogdec-returns');
 
 export function InjectLogger(
   target: any,
   propertyKey: string | symbol,
-  parameterIndex: number
+  parameterIndex: number,
 ) {
   Reflect.defineMetadata(scopedLogger, parameterIndex, target, propertyKey);
 }
 
-type ParameterDecoratorType = (target: any, propertyKey: string | symbol, parameterIndex: number) => void
+type ParameterDecoratorType = (
+  target: any,
+  propertyKey: string | symbol,
+  parameterIndex: number,
+) => void;
 
 function createLoggedFunctionParam(
   name: string,
-  options?: IncludeExcludePath
+  options?: IncludeExcludePath,
 ): ParameterDecoratorType {
   return (
     target: any,
     propertyKey: string | symbol,
-    parameterIndex: number
+    parameterIndex: number,
   ) => {
     const existingLoggedParams: LoggedParamReflectData[] =
       Reflect.getOwnMetadata(loggedParam, target, propertyKey) || [];
@@ -60,33 +70,34 @@ function createLoggedFunctionParam(
       include:
         options &&
         options.includePath &&
-        options.includePath.map((v) => (Array.isArray(v) ? v.join(".") : v)),
+        options.includePath.map((v) => (Array.isArray(v) ? v.join('.') : v)),
       exclude:
         options &&
         options.excludePath &&
-        options.excludePath.map((v) => (Array.isArray(v) ? v.join(".") : v)),
+        options.excludePath.map((v) => (Array.isArray(v) ? v.join('.') : v)),
     });
 
     Reflect.defineMetadata(
       loggedParam,
       existingLoggedParams,
       target,
-      propertyKey
+      propertyKey,
     );
   };
 }
 
-type LoggedParamReturns = (name: string, options?: IncludeExcludePath) => ParameterDecoratorType;
+type LoggedParamReturns = (
+  name: string,
+  options?: IncludeExcludePath,
+) => ParameterDecoratorType;
 
 export const Logged: LoggedParamReturns = (name, options) =>
-  createLoggedFunctionParam(name, options)
+  createLoggedFunctionParam(name, options);
 
-type Pipe = Type<PipeTransform> | PipeTransform
+type Pipe = Type<PipeTransform> | PipeTransform;
 
 export function LoggedParam(): LoggedParamReturns;
-export function LoggedParam(
+export function LoggedParam(...pipes: Pipe[]): LoggedParamReturns;
-  ...pipes: Pipe[]
-): LoggedParamReturns;
 export function LoggedParam(
   property: string,
   ...pipes: Pipe[]
@@ -97,10 +108,7 @@ export function LoggedParam(
 ): LoggedParamReturns {
   return (name, options) => {
     return (target, propertyKey, parameterIndex) => {
-      createPipesRouteParamDecorator(RouteParamtypes.PARAM)(
+      createPipesRouteParamDecorator(RouteParamtypes.PARAM)(property, ...pipes)(
-        property,
-        ...pipes,
-      )(
         target,
         propertyKey,
         parameterIndex,
@@ -109,15 +117,13 @@ export function LoggedParam(
         target,
         propertyKey,
         parameterIndex,
-      )
+      );
-    }
+    };
-  }
+  };
 }
 
 export function LoggedQuery(): LoggedParamReturns;
-export function LoggedQuery(
+export function LoggedQuery(...pipes: Pipe[]): LoggedParamReturns;
-  ...pipes: Pipe[]
-): LoggedParamReturns;
 export function LoggedQuery(
   property: string,
   ...pipes: Pipe[]
@@ -128,23 +134,23 @@ export function LoggedQuery(
 ): LoggedParamReturns {
   return (name, options) => {
     return (target, propertyKey, parameterIndex) => {
-      createPipesRouteParamDecorator(RouteParamtypes.QUERY)(
+      createPipesRouteParamDecorator(RouteParamtypes.QUERY)(property, ...pipes)(
-        property, ...pipes
+        target,
-      )(
+        propertyKey,
-        target, propertyKey, parameterIndex,
+        parameterIndex,
       );
 
       createLoggedFunctionParam(name, options)(
-        target, propertyKey, parameterIndex,
+        target,
+        propertyKey,
+        parameterIndex,
       );
-    }
+    };
-  }
+  };
 }
 
 export function LoggedBody(): LoggedParamReturns;
-export function LoggedBody(
+export function LoggedBody(...pipes: Pipe[]): LoggedParamReturns;
-  ...pipes: Pipe[]
-): LoggedParamReturns;
 export function LoggedBody(
   property: string,
   ...pipes: Pipe[]
@@ -155,41 +161,50 @@ export function LoggedBody(
 ): LoggedParamReturns {
   return (name, options) => {
     return (target, propertyKey, parameterIndex) => {
-      createPipesRouteParamDecorator(RouteParamtypes.BODY)(
+      createPipesRouteParamDecorator(RouteParamtypes.BODY)(property, ...pipes)(
-        property,
+        target,
-        ...pipes,
+        propertyKey,
-      )(
+        parameterIndex,
-        target, propertyKey, parameterIndex
       );
 
       createLoggedFunctionParam(name, options)(
-        target, propertyKey, parameterIndex,
+        target,
+        propertyKey,
+        parameterIndex,
       );
-    }
+    };
-  }
+  };
 }
 
 export function LoggedHeaders(property?: string): LoggedParamReturns {
   return (name, options) => {
     return (target, propertyKey, parameterIndex) => {
       createRouteParamDecorator(RouteParamtypes.HEADERS)(property)(
-        target, propertyKey, parameterIndex,
+        target,
+        propertyKey,
+        parameterIndex,
       );
 
       createLoggedFunctionParam(name, options)(
-        target, propertyKey, parameterIndex,
+        target,
-      )
+        propertyKey,
-    }
+        parameterIndex,
-  }
+      );
+    };
+  };
 }
 
-export function Returns<F extends Array<any>, R>(namePaths?: {
+export function Returns<F extends Array<any>, R>(
-  [name: string]: string;
+  namePaths?:
-} | string) {
+    | {
+        [name: string]: string;
+      }
+    | string,
+) {
   return (
     _target: any,
     _key: string | symbol,
-    descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R> | R>
+    descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R> | R>,
   ) => {
     Reflect.defineMetadata(
       returns,
@@ -198,10 +213,10 @@ export function Returns<F extends Array<any>, R>(namePaths?: {
           ? namePaths
           : Object.entries(namePaths).reduce<ReturnsReflectData[]>(
               (prev, curr) => [...prev, { name: curr[0], path: curr[1] }],
-              []
+              [],
             )
         : true,
-      descriptor.value
+      descriptor.value,
     );
   };
 }

src/test/index.ts

@@ -1,10 +1,6 @@
-import { LoggedFunction, LoggedInjectable } from "../logged";
+import { LoggedFunction, LoggedInjectable } from '../logged';
-import { ScopedLogger } from "../logger";
+import { ScopedLogger } from '../logger';
-import {
+import { InjectLogger, Logged, Returns } from '../reflected';
-  InjectLogger,
-  Logged,
-  Returns,
-} from "../reflected";
 
 type TestObject = {
   a: string;
@@ -17,151 +13,149 @@ type TestObject = {
 class TestService {
   public async service(paramA: string, @InjectLogger logger: ScopedLogger) {
     logger.log(`received paramA ${paramA}`);
-    return paramA
+    return paramA;
   }
 }
 
 @LoggedInjectable()
 class LoggedClass {
-  constructor(
+  constructor(private service: TestService) {}
-    private service: TestService
-  ) { }
 
-  async testParameterLoggingWithoutInjection(@Logged("key") key: number) {
+  async testParameterLoggingWithoutInjection(@Logged('key') key: number) {
     console.log(key);
   }
 
   async testMultiParameterLoggingWithoutInjection(
-    @Logged("key") key: number,
+    @Logged('key') key: number,
-    @Logged("key2") key2: string
+    @Logged('key2') key2: string,
   ) {
     console.log(key, key2);
   }
 
   async testParameterLoggingWithInjection(
-    @Logged("key") key: number,
+    @Logged('key') key: number,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(key.toString());
   }
 
   async testMultiParameterLoggingWithInjection(
-    @Logged("key") key: number,
+    @Logged('key') key: number,
-    @Logged("key2") key2: string,
+    @Logged('key2') key2: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(key.toString() + key2);
   }
 
   async testObjectParameterLogging(
-    @Logged("key") key: TestObject,
+    @Logged('key') key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   async testObjectParameterDotIncludeLogging(
-    @Logged("key", { includePath: ["a", "b.c", "d.0", "e"] })
+    @Logged('key', { includePath: ['a', 'b.c', 'd.0', 'e'] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   async testObjectParameterArrayIncludeLogging(
-    @Logged("key", { includePath: [["a"], ["b", "c"], ["d", "0"], ["e"]] })
+    @Logged('key', { includePath: [['a'], ['b', 'c'], ['d', '0'], ['e']] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   async testObjectParameterDotExcludeLogging(
-    @Logged("key", { excludePath: ["a", "b.c", "d.0", "e"] })
+    @Logged('key', { excludePath: ['a', 'b.c', 'd.0', 'e'] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   async testObjectParameterArrayExcludeLogging(
-    @Logged("key", { excludePath: [["a"], ["b", "c"], ["d", "0"], ["e"]] })
+    @Logged('key', { excludePath: [['a'], ['b', 'c'], ['d', '0'], ['e']] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
-  @Returns({ result: "http.result", userId: "body.user.id" })
+  @Returns({ result: 'http.result', userId: 'body.user.id' })
   async testReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return {
       http: {
-        result: "success",
+        result: 'success',
         code: 200,
       },
       body: {
         user: {
           id: userId,
-          name: "tester",
+          name: 'tester',
         },
-        secret: "supersecret",
+        secret: 'supersecret',
       },
     };
   }
 
-  @Returns({ result: "http.result", userId: "body.user.id" })
+  @Returns({ result: 'http.result', userId: 'body.user.id' })
   async testMissingReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return {
       body: {
         user: {
           id: userId,
-          name: "tester",
+          name: 'tester',
         },
-        secret: "supersecret",
+        secret: 'supersecret',
       },
     };
   }
 
   @Returns()
   async testRawObjectReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return {
       body: {
         user: {
           id: userId,
-          name: "tester",
+          name: 'tester',
         },
-        secret: "supersecret",
+        secret: 'supersecret',
       },
     };
   }
 
   @Returns()
   async testRawValueReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return true;
   }
 
   async testLoggerRootLogging2(@InjectLogger logger?: ScopedLogger) {
-    logger.log("2");
+    logger.log('2');
   }
 
   async testLoggerRootLogging(@InjectLogger logger?: ScopedLogger) {
@@ -169,16 +163,16 @@ class LoggedClass {
   }
 
   testSyncLoggerRootLogging2(@InjectLogger logger?: ScopedLogger) {
-    logger.log('2')
+    logger.log('2');
-    return 2
+    return 2;
   }
 
   testSyncLoggerRootLogging(@InjectLogger logger?: ScopedLogger) {
-    logger.log(this.testSyncLoggerRootLogging2(logger).toString())
+    logger.log(this.testSyncLoggerRootLogging2(logger).toString());
   }
 
   testSyncLogging(@InjectLogger logger?: ScopedLogger) {
-    logger.log("synced yay");
+    logger.log('synced yay');
   }
 
   async testService(@InjectLogger logger?: ScopedLogger) {
@@ -187,128 +181,126 @@ class LoggedClass {
 
   @LoggedFunction({ skipCallLog: true, skipReturnLog: true })
   testOptionOverriding(@InjectLogger logger?: ScopedLogger) {
-    logger.log("testOptionOverriding");
+    logger.log('testOptionOverriding');
   }
 }
 
 class LoggedMethodsClass {
-  constructor(
+  constructor(private service: TestService) {}
-    private service: TestService
-  ) { }
 
   @LoggedFunction()
-  async testParameterLoggingWithoutInjection(@Logged("key") key: number) {
+  async testParameterLoggingWithoutInjection(@Logged('key') key: number) {
     console.log(key);
   }
 
   @LoggedFunction()
   async testMultiParameterLoggingWithoutInjection(
-    @Logged("key") key: number,
+    @Logged('key') key: number,
-    @Logged("key2") key2: string
+    @Logged('key2') key2: string,
   ) {
     console.log(key, key2);
   }
 
   @LoggedFunction()
   async testParameterLoggingWithInjection(
-    @Logged("key") key: number,
+    @Logged('key') key: number,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(key.toString());
   }
 
   @LoggedFunction()
   async testMultiParameterLoggingWithInjection(
-    @Logged("key") key: number,
+    @Logged('key') key: number,
-    @Logged("key2") key2: string,
+    @Logged('key2') key2: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(key.toString() + key2);
   }
 
   @LoggedFunction()
   async testObjectParameterLogging(
-    @Logged("key") key: TestObject,
+    @Logged('key') key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   @LoggedFunction()
   async testObjectParameterDotIncludeLogging(
-    @Logged("key", { includePath: ["a", "b.c", "d.0", "e"] })
+    @Logged('key', { includePath: ['a', 'b.c', 'd.0', 'e'] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   @LoggedFunction()
   async testObjectParameterArrayIncludeLogging(
-    @Logged("key", { includePath: [["a"], ["b", "c"], ["d", "0"], ["e"]] })
+    @Logged('key', { includePath: [['a'], ['b', 'c'], ['d', '0'], ['e']] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   @LoggedFunction()
   async testObjectParameterDotExcludeLogging(
-    @Logged("key", { excludePath: ["a", "b.c", "d.0", "e"] })
+    @Logged('key', { excludePath: ['a', 'b.c', 'd.0', 'e'] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   @LoggedFunction()
   async testObjectParameterArrayExcludeLogging(
-    @Logged("key", { excludePath: [["a"], ["b", "c"], ["d", "0"], ["e"]] })
+    @Logged('key', { excludePath: [['a'], ['b', 'c'], ['d', '0'], ['e']] })
     key: TestObject,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(JSON.stringify(key));
   }
 
   @LoggedFunction()
-  @Returns({ result: "http.result", userId: "body.user.id" })
+  @Returns({ result: 'http.result', userId: 'body.user.id' })
   async testReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
 
     return {
       http: {
-        result: "success",
+        result: 'success',
         code: 200,
       },
       body: {
         user: {
           id: userId,
-          name: "tester",
+          name: 'tester',
         },
-        secret: "supersecret",
+        secret: 'supersecret',
       },
     };
   }
 
   @LoggedFunction()
-  @Returns({ result: "http.result", userId: "body.user.id" })
+  @Returns({ result: 'http.result', userId: 'body.user.id' })
   async testMissingReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return {
       body: {
         user: {
           id: userId,
-          name: "tester",
+          name: 'tester',
         },
-        secret: "supersecret",
+        secret: 'supersecret',
       },
     };
   }
@@ -316,18 +308,18 @@ class LoggedMethodsClass {
   @LoggedFunction()
   @Returns()
   async testRawObjectReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return {
       body: {
         user: {
           id: userId,
-          name: "tester",
+          name: 'tester',
         },
-        secret: "supersecret",
+        secret: 'supersecret',
       },
     };
   }
@@ -335,9 +327,9 @@ class LoggedMethodsClass {
   @LoggedFunction()
   @Returns()
   async testRawValueReturnLogging(
-    @Logged("userId")
+    @Logged('userId')
     userId: string,
-    @InjectLogger logger?: ScopedLogger
+    @InjectLogger logger?: ScopedLogger,
   ) {
     logger.log(userId);
     return true;
@@ -345,7 +337,7 @@ class LoggedMethodsClass {
 
   @LoggedFunction()
   async testLoggerRootLogging2(@InjectLogger logger?: ScopedLogger) {
-    logger.log("2");
+    logger.log('2');
   }
 
   @LoggedFunction()
@@ -355,18 +347,18 @@ class LoggedMethodsClass {
 
   @LoggedFunction()
   testSyncLoggerRootLogging2(@InjectLogger logger?: ScopedLogger) {
-    logger.log('2')
+    logger.log('2');
-    return 2
+    return 2;
   }
 
   @LoggedFunction()
   testSyncLoggerRootLogging(@InjectLogger logger?: ScopedLogger) {
-    logger.log(this.testSyncLoggerRootLogging2(logger).toString())
+    logger.log(this.testSyncLoggerRootLogging2(logger).toString());
   }
 
   @LoggedFunction()
   testSyncLogging(@InjectLogger logger?: ScopedLogger) {
-    logger.log("synced yay");
+    logger.log('synced yay');
   }
 
   @LoggedFunction()
@@ -375,8 +367,6 @@ class LoggedMethodsClass {
   }
 }
 
-
-
 // const service = new TestService();
 
 /**

src/utils.ts

@@ -1,9 +1,9 @@
-import { Logger } from "@nestjs/common";
+import { Logger } from '@nestjs/common';
-import { ScopedLogger } from "./logger";
+import { ScopedLogger } from './logger';
-import { REQUEST_LOG_ID } from "./logged/utils";
+import { REQUEST_LOG_ID } from './logged/utils';
 
 const logger = new Logger();
 
 export function getRequestLogger(functionName: string, req: any): ScopedLogger {
-    return new ScopedLogger(logger, [functionName], req[REQUEST_LOG_ID])
+  return new ScopedLogger(logger, [functionName], req[REQUEST_LOG_ID]);
-}
+}

yarn.lock

@@ -372,6 +372,7 @@ __metadata:
     "@nestjs/common": "npm:^10.2.8"
     "@types/node": "npm:^20.9.1"
     hyperid: "npm:^3.1.1"
+    prettier: "npm:^3.5.3"
     reflect-metadata: "npm:^0.1.13"
     rimraf: "npm:^5.0.5"
     rxjs: "npm:^7.8.1"
@@ -397,6 +398,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"prettier@npm:^3.5.3":
+  version: 3.5.3
+  resolution: "prettier@npm:3.5.3"
+  bin:
+    prettier: bin/prettier.cjs
+  checksum: 10c0/3880cb90b9dc0635819ab52ff571518c35bd7f15a6e80a2054c05dbc8a3aa6e74f135519e91197de63705bcb38388ded7e7230e2178432a1468005406238b877
+  languageName: node
+  linkType: hard
+
 "reflect-metadata@npm:^0.1.13":
   version: 0.1.13
   resolution: "reflect-metadata@npm:0.1.13"