p-sw/nestlogged
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: prettified

Browse Source
This commit is contained in:
Shinwoo PARK 2023-12-03 18:46:25 +09:00
parent 185e22cb84
commit a8f7cb4f95
1 changed files with 144 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

284
src/logged.ts
View File

@ -1,164 +1,168 @@
import {Logger} from "@nestjs/common";
import {ScopedLogger} from "./logger";
import {LoggedParamReflectData} from "./reflected";
import {loggedParam, scopedLogger} from "./reflected";
import { Logger } from "@nestjs/common";
import { ScopedLogger } from "./logger";
import { LoggedParamReflectData } from "./reflected";
import { loggedParam, scopedLogger } from "./reflected";
import objectContainedLogged from "./functions";
function loggerInit(_target: any) {
if (!Object.getOwnPropertyNames(_target).includes('logger')) {
const newTargetLogger = new Logger(_target.constructor.name);
newTargetLogger.log('Logger Initialized.');
Object.defineProperty(_target, 'logger', {
writable: false,
enumerable: false,
configurable: false,
value: newTargetLogger,
});
}
if (!Object.getOwnPropertyNames(_target).includes("logger")) {
const newTargetLogger = new Logger(_target.constructor.name);
newTargetLogger.log("Logger Initialized.");
Object.defineProperty(_target, "logger", {
writable: false,
enumerable: false,
configurable: false,
value: newTargetLogger,
});
}
}
export function LoggedFunction<F extends Array<any>, R>(
_target: any,
key: string,
descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R>>
) {
loggerInit(_target);
const logger = _target.logger;
const fn = descriptor.value;
if (!fn) return;
descriptor.value = async function (...args: F) {
const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
scopedLogger,
_target,
key
);
if (
typeof scopedLoggerInjectableParam !== "undefined" &&
(args.length <= scopedLoggerInjectableParam ||
!(args[scopedLoggerInjectableParam] instanceof ScopedLogger))
) {
args[scopedLoggerInjectableParam] = new ScopedLogger(logger, key);
} else if (typeof scopedLoggerInjectableParam !== "undefined") {
args[scopedLoggerInjectableParam] = new ScopedLogger(
args[scopedLoggerInjectableParam],
key
);
}
const injectedLogger =
typeof scopedLoggerInjectableParam !== "undefined"
? args[scopedLoggerInjectableParam]
: logger;
const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
loggedParam,
_target,
key
);
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(", ")
: ""
}`
);
try {
const r: R = await fn.call(this, ...args);
injectedLogger.log(`RETURNED ${key}`);
return r;
} catch (e) {
injectedLogger.error(`WHILE ${key} ERROR ${e}`);
throw e;
}
};
}
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);
const logger = _target.logger;
const fullRoute = `${_target.constructor.name}/${route}`;
const fn = descriptor.value;
if (!fn) return;
descriptor.value = async function (...args: F) {
const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
scopedLogger,
_target,
key,
);
const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
scopedLogger,
_target,
key
);
if (
typeof scopedLoggerInjectableParam !== 'undefined' &&
(args.length <= scopedLoggerInjectableParam ||
!(args[scopedLoggerInjectableParam] instanceof ScopedLogger))
) {
args[scopedLoggerInjectableParam] = new ScopedLogger(logger, key);
} else if (typeof scopedLoggerInjectableParam !== 'undefined') {
args[scopedLoggerInjectableParam] = new ScopedLogger(
args[scopedLoggerInjectableParam],
key,
);
}
if (
typeof scopedLoggerInjectableParam !== "undefined" &&
(args.length <= scopedLoggerInjectableParam ||
!(args[scopedLoggerInjectableParam] instanceof ScopedLogger))
) {
args[scopedLoggerInjectableParam] = new ScopedLogger(logger, fullRoute);
}
const injectedLogger=
typeof scopedLoggerInjectableParam !== 'undefined'
? args[scopedLoggerInjectableParam]
: logger;
const injectedLogger =
typeof scopedLoggerInjectableParam !== "undefined"
? args[scopedLoggerInjectableParam]
: logger;
const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
loggedParam,
_target,
key,
)
const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
loggedParam,
_target,
key
);
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(', ')
: ''
}`,
);
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(", ")
: ""
}`
);
try {
const r: R = await fn.call(this, ...args);
injectedLogger.log(`RETURNED ${key}`);
return r;
} catch (e) {
injectedLogger.error(`WHILE ${key} ERROR ${e}`);
throw e;
}
try {
const r: R = await fn.call(this, ...args);
injectedLogger.log(`RETURNED RESPONSE ${fullRoute} (${key})`);
return r;
} catch (e) {
injectedLogger.error(`WHILE HTTP ${fullRoute} (${key}) ERROR ${e}`);
throw e;
}
};
}
export function LoggedRoute<F extends Array<any>, R>(route: string) {
return (
_target: any,
key: string,
descriptor: TypedPropertyDescriptor<(...args: F) => Promise<R>>,
) => {
loggerInit(_target);
const logger = _target.logger;
const fullRoute = `${_target.constructor.name}/${route}`;
const fn = descriptor.value;
if (!fn) return;
descriptor.value = async function (...args: F) {
const scopedLoggerInjectableParam: number = Reflect.getOwnMetadata(
scopedLogger,
_target,
key,
);
if (
typeof scopedLoggerInjectableParam !== 'undefined' &&
(args.length <= scopedLoggerInjectableParam ||
!(args[scopedLoggerInjectableParam] instanceof ScopedLogger))
) {
args[scopedLoggerInjectableParam] = new ScopedLogger(logger, fullRoute);
}
const injectedLogger=
typeof scopedLoggerInjectableParam !== 'undefined'
? args[scopedLoggerInjectableParam]
: logger;
const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
loggedParam,
_target,
key,
)
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(', ')
: ''
}`,
);
try {
const r: R = await fn.call(this, ...args);
injectedLogger.log(`RETURNED RESPONSE ${fullRoute} (${key})`);
return r;
} catch (e) {
injectedLogger.error(`WHILE HTTP ${fullRoute} (${key}) ERROR ${e}`);
throw e;
}
};
}
};
}