style: prettified

src/functions.ts

@@ -1,10 +1,10 @@
-export const notIncludedSymbol = Symbol('notIncluded')
+export const notIncludedSymbol = Symbol("notIncluded");
 
 export async function includeOrExcludeObject(
   ocv: any,
   paths: string[],
   currentPath: string[] = [],
-    include: boolean, // or exclude
+  include: boolean // or exclude
 ) {
   if (Array.isArray(ocv)) {
     return (
@@ -15,14 +15,14 @@ export async function includeOrExcludeObject(
               v,
               paths,
               [...currentPath, i.toString()],
-                            include,
-                        ),
-                ),
+              include
+            )
+        )
       )
     ).filter((e) => e !== notIncludedSymbol);
   }
 
-    if (typeof ocv === 'object') {
+  if (typeof ocv === "object") {
     return Object.fromEntries(
       (
         await Promise.all(
@@ -32,15 +32,15 @@ export async function includeOrExcludeObject(
               value,
               paths,
               [...currentPath, key],
-                            include,
+              include
             ),
-                    ]),
+          ])
         )
-            ).filter((e) => e[1] !== notIncludedSymbol),
+      ).filter((e) => e[1] !== notIncludedSymbol)
     );
   }
 
-    const isIncluded = paths.includes(currentPath.join('.'));
+  const isIncluded = paths.includes(currentPath.join("."));
 
   return include
     ? isIncluded // include mode, path is in list
@@ -48,27 +48,27 @@ export async function includeOrExcludeObject(
       : notIncludedSymbol
     : isIncluded // exclude mode, path is in list
     ? notIncludedSymbol
-            : ocv
+    : ocv;
 }
 
 export default async function objectContainedLogged(
   ocv: any,
-    options?: {include?: string[]; exclude: string[]},
+  options?: { include?: string[]; exclude: string[] }
 ): Promise<string> {
-    if (options && typeof ocv === 'object') {
+  if (options && typeof ocv === "object") {
     if (options.include && options.include.length > 0) {
       return JSON.stringify(
-                await includeOrExcludeObject(ocv, options.include, [], true),
+        await includeOrExcludeObject(ocv, options.include, [], true)
       );
     }
     if (options.exclude && options.exclude.length > 0) {
       return JSON.stringify(
-                await includeOrExcludeObject(ocv, options.exclude, [], false),
+        await includeOrExcludeObject(ocv, options.exclude, [], false)
       );
     }
   }
 
-    if (typeof ocv === 'object') {
+  if (typeof ocv === "object") {
     return JSON.stringify(ocv);
   } else {
     return `${ocv}`;

src/index.ts

@@ -1,3 +1,3 @@
-export {LoggedRoute, LoggedFunction} from './logged';
-export {ScopedLogger} from './logger';
-export {LoggedParamReflectData, InjectLogger, LoggedParam} from './reflected';
+export { LoggedRoute, LoggedFunction } from "./logged";
+export { ScopedLogger } from "./logger";
+export { LoggedParamReflectData, InjectLogger, LoggedParam } from "./reflected";

src/logger.ts

@@ -1,12 +1,12 @@
-import {Logger} from "@nestjs/common";
+import { Logger } from "@nestjs/common";
 
-type LogLevel = 'debug' | 'log' | 'warn' | 'verbose' | 'error' | 'fatal';
+type LogLevel = "debug" | "log" | "warn" | "verbose" | "error" | "fatal";
 
 export class ScopedLogger extends Logger {
   constructor(
     private logger: Logger,
     private scope: string,
-        private scopeId?: string,
+    private scopeId?: string
   ) {
     super();
   }
@@ -14,17 +14,15 @@ export class ScopedLogger extends Logger {
   private scopedLog(method: LogLevel) {
     return (message: string) => {
       this.logger[method](
-                `-> ${this.scope}${
-                    this.scopeId ? `(${this.scopeId})` : ''
-                }: ${message}`,
+        `-> ${this.scope}${this.scopeId ? `(${this.scopeId})` : ""}: ${message}`
       );
     };
   }
 
-    debug = this.scopedLog('debug');
-    log = this.scopedLog('log');
-    warn = this.scopedLog('warn');
-    verbose = this.scopedLog('verbose');
-    error = this.scopedLog('error');
-    fatal = this.scopedLog('fatal');
+  debug = this.scopedLog("debug");
+  log = this.scopedLog("log");
+  warn = this.scopedLog("warn");
+  verbose = this.scopedLog("verbose");
+  error = this.scopedLog("error");
+  fatal = this.scopedLog("fatal");
 }

src/reflected.ts

@@ -5,14 +5,13 @@ export interface LoggedParamReflectData {
   exclude?: string[];
 }
 
-export const scopedLogger = Symbol('scopedLogger');
-export const loggedParam = Symbol('loggedParam');
-
+export const scopedLogger = Symbol("scopedLogger");
+export const loggedParam = Symbol("loggedParam");
 
 export function InjectLogger(
   target: any,
   propertyKey: string | symbol,
-    parameterIndex: number,
+  parameterIndex: number
 ) {
   Reflect.defineMetadata(scopedLogger, parameterIndex, target, propertyKey);
 }
@@ -22,12 +21,12 @@ export function LoggedParam(
   options?: {
     includePath?: (string | string[])[];
     excludePath?: (string | string[])[];
-    },
+  }
 ) {
   return (
     target: any,
     propertyKey: string | symbol,
-        parameterIndex: number,
+    parameterIndex: number
   ) => {
     const existingLoggedParams: LoggedParamReflectData[] =
       Reflect.getOwnMetadata(loggedParam, target, propertyKey) || [];
@@ -38,11 +37,11 @@ export function LoggedParam(
       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(