From 81ff8a3719be7fc5e465f24ff4a1df991492b603 Mon Sep 17 00:00:00 2001 From: Shinwoo PARK Date: Sun, 3 Dec 2023 22:04:15 +0900 Subject: [PATCH] fix: fix behavior and logging in logged controller and logged route --- dist/lib/logged.d.ts | 3 +- dist/lib/logged.js | 25 ++++++++-- src/logged.ts | 111 +++++++++++++++++++++++++++---------------- 3 files changed, 91 insertions(+), 48 deletions(-) diff --git a/dist/lib/logged.d.ts b/dist/lib/logged.d.ts index dddbe74..1107615 100644 --- a/dist/lib/logged.d.ts +++ b/dist/lib/logged.d.ts @@ -1,7 +1,8 @@ import { ControllerOptions, ScopeOptions } from "@nestjs/common"; +import { RequestMethod } from "@nestjs/common"; export declare function LoggedInjectable(options?: ScopeOptions): (target: any) => void; export declare function LoggedController(): (target: any) => void; export declare function LoggedController(prefix: string | string[]): (target: any) => void; export declare function LoggedController(options: ControllerOptions): (target: any) => void; export declare function LoggedFunction, R>(_target: any, key: string, descriptor: TypedPropertyDescriptor<(...args: F) => Promise>): void; -export declare function LoggedRoute, R>(route?: string): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(...args: F) => Promise>) => void; +export declare function LoggedRoute, R>(route?: string): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(...args: F) => Promise>) => [string, RequestMethod]; diff --git a/dist/lib/logged.js b/dist/lib/logged.js index fa75d4f..aab2f18 100644 --- a/dist/lib/logged.js +++ b/dist/lib/logged.js @@ -5,6 +5,17 @@ const common_1 = require("@nestjs/common"); const logger_1 = require("./logger"); const reflected_1 = require("./reflected"); const functions_1 = require("./functions"); +const RevRequestMethod = [ + "GET", + "POST", + "PUT", + "DELETE", + "PATCH", + "ALL", + "OPTIONS", + "HEAD", + "SEARCH", +]; function loggerInit(_target) { if (!Object.getOwnPropertyNames(_target).includes("logger")) { const newTargetLogger = new common_1.Logger(_target.constructor.name); @@ -40,15 +51,17 @@ function LoggedController(param) { loggerInit(target.prototype); const logger = target.prototype.logger; const methods = Object.getOwnPropertyNames(target.prototype); - logger.log(JSON.stringify(methods)); methods.forEach((method) => { - logger.log(method); if (method !== "constructor" && typeof target.prototype[method] === "function") { - logger.log(`LoggedRoute applied to ${method}`); + const path = Reflect.getMetadata("path", target.prototype[method]); + const httpMethod = Reflect.getMetadata("method", target.prototype[method]); + logger.log(`LoggedRoute applied to ${method} (${RevRequestMethod[httpMethod]} ${path})`); LoggedRoute()(target.prototype, method, { value: target.prototype[method], }); + Reflect.defineMetadata("path", path, target.prototype[method]); + Reflect.defineMetadata("method", httpMethod, target.prototype[method]); } }); (0, common_1.Controller)(param)(target); @@ -102,15 +115,16 @@ function LoggedRoute(route) { return (_target, key, descriptor) => { loggerInit(_target); const logger = _target.logger; - let fullRoute = `${_target.constructor.name}/`; const fn = descriptor.value; + const httpPath = Reflect.getMetadata("path", fn); + const httpMethod = Reflect.getMetadata("method", fn); + const fullRoute = `${_target.constructor.name}::${route ?? httpPath}[${RevRequestMethod[httpMethod]}]`; if (!fn || typeof fn !== "function") { logger.warn(`LoggedRoute decorator applied to non-function property: ${key}`); return; } _target[key] = async function (...args) { const scopedLoggerInjectableParam = Reflect.getOwnMetadata(reflected_1.scopedLogger, _target, key); - fullRoute += route || Reflect.getMetadata("path", fn); if (typeof scopedLoggerInjectableParam !== "undefined" && (args.length <= scopedLoggerInjectableParam || !(args[scopedLoggerInjectableParam] instanceof logger_1.ScopedLogger))) { @@ -139,6 +153,7 @@ function LoggedRoute(route) { throw e; } }; + return [httpPath, httpMethod]; }; } exports.LoggedRoute = LoggedRoute; diff --git a/src/logged.ts b/src/logged.ts index 4df1342..b59aef4 100644 --- a/src/logged.ts +++ b/src/logged.ts @@ -9,6 +9,19 @@ import { ScopedLogger } from "./logger"; import { LoggedParamReflectData } from "./reflected"; import { loggedParam, scopedLogger } from "./reflected"; import objectContainedLogged from "./functions"; +import { RequestMethod } from "@nestjs/common"; + +const RevRequestMethod = [ + "GET", + "POST", + "PUT", + "DELETE", + "PATCH", + "ALL", + "OPTIONS", + "HEAD", + "SEARCH", +]; function loggerInit(_target: any) { if (!Object.getOwnPropertyNames(_target).includes("logger")) { @@ -63,18 +76,24 @@ export function LoggedController(param?: any): (target: any) => void { const methods = Object.getOwnPropertyNames(target.prototype); - logger.log(JSON.stringify(methods)) - methods.forEach((method) => { - logger.log(method) if ( method !== "constructor" && typeof target.prototype[method] === "function" ) { - logger.log(`LoggedRoute applied to ${method}`); + const path = Reflect.getMetadata("path", target.prototype[method]); + const httpMethod = Reflect.getMetadata( + "method", + target.prototype[method] + ); + logger.log( + `LoggedRoute applied to ${method} (${RevRequestMethod[httpMethod]} ${path})` + ); LoggedRoute()(target.prototype, method, { value: target.prototype[method], }); + Reflect.defineMetadata("path", path, target.prototype[method]); + Reflect.defineMetadata("method", httpMethod, target.prototype[method]); } }); @@ -100,7 +119,7 @@ export function LoggedFunction, R>( return; } - _target[key] = async function(...args: F) { + _target[key] = async function (...args: F) { const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata( scopedLogger, _target, @@ -132,22 +151,23 @@ export function LoggedFunction, R>( ); injectedLogger.log( - `CALL ${key} ${loggedParams && loggedParams.length > 0 - ? "WITH " + - ( - await Promise.all( - loggedParams.map( - async ({ name, index, include, exclude }) => - name + - "=" + - (await objectContainedLogged(args[index], { - include, - exclude, - })) - ) - ) - ).join(", ") - : "" + `CALL ${key} ${ + loggedParams && loggedParams.length > 0 + ? "WITH " + + ( + await Promise.all( + loggedParams.map( + async ({ name, index, include, exclude }) => + name + + "=" + + (await objectContainedLogged(args[index], { + include, + exclude, + })) + ) + ) + ).join(", ") + : "" }` ); @@ -167,14 +187,20 @@ export function LoggedRoute, R>(route?: string) { _target: any, key: string, descriptor: TypedPropertyDescriptor<(...args: F) => Promise> - ) => { + ): [string, RequestMethod] => { loggerInit(_target); const logger = _target.logger; - let fullRoute = `${_target.constructor.name}/`; const fn = descriptor.value; + const httpPath: string = Reflect.getMetadata("path", fn); + const httpMethod: RequestMethod = Reflect.getMetadata("method", fn); + + const fullRoute = `${_target.constructor.name}::${route ?? httpPath}[${ + RevRequestMethod[httpMethod] + }]`; + if (!fn || typeof fn !== "function") { logger.warn( `LoggedRoute decorator applied to non-function property: ${key}` @@ -182,15 +208,13 @@ export function LoggedRoute, R>(route?: string) { return; } - _target[key] = async function(...args: F) { + _target[key] = async function (...args: F) { const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata( scopedLogger, _target, key ); - fullRoute += route || Reflect.getMetadata("path", fn); - if ( typeof scopedLoggerInjectableParam !== "undefined" && (args.length <= scopedLoggerInjectableParam || @@ -211,22 +235,23 @@ export function LoggedRoute, R>(route?: string) { ); injectedLogger.log( - `HIT HTTP ${fullRoute} (${key}) ${loggedParams && loggedParams.length > 0 - ? "WITH " + - ( - await Promise.all( - loggedParams.map( - async ({ name, index, include, exclude }) => - name + - "=" + - (await objectContainedLogged(args[index], { - include, - exclude, - })) - ) - ) - ).join(", ") - : "" + `HIT HTTP ${fullRoute} (${key}) ${ + loggedParams && loggedParams.length > 0 + ? "WITH " + + ( + await Promise.all( + loggedParams.map( + async ({ name, index, include, exclude }) => + name + + "=" + + (await objectContainedLogged(args[index], { + include, + exclude, + })) + ) + ) + ).join(", ") + : "" }` ); @@ -239,5 +264,7 @@ export function LoggedRoute, R>(route?: string) { throw e; } }; + + return [httpPath, httpMethod]; }; }