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

style: add prettier

Browse Source
This commit is contained in:
Shinwoo PARK 2025-03-21 09:38:36 +09:00
parent b28bb9e193
commit 3ac9b1d38d
22 changed files with 617 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
.prettierrc Normal file
View File

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

BIN
.yarn/install-state.gz
View File

Binary file not shown.

4
package.json
View File

@ -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"
}

12
src/index.ts
View File

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

64
src/internals/nest.ts
View File

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

59
src/internals/utils.ts
View File

@ -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 lastIndex = (path.length - 1).toString()
const path = dotpath.split('.');
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(
includeObjectSync(ocv, { paths: options.include })
);
return JSON.stringify(includeObjectSync(ocv, { paths: options.include }));
}
if (options.exclude && options.exclude.length > 0) {
return JSON.stringify(
excludeObjectSync(ocv, { paths: options.exclude })
)
return JSON.stringify(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;
}
}

114
src/logged/class.ts
View File

@ -3,30 +3,24 @@ import {
Controller,
ControllerOptions,
ScopeOptions,
} from "@nestjs/common";
import {
loggerInit,
RevRequestMethod
} from './utils';
import {
LoggedRoute,
LoggedFunction
} from "./methods";
} from '@nestjs/common';
import { loggerInit, 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" &&
typeof target.prototype[method] === "function"
method !== 'constructor' &&
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(
prefix: string | string[]
): (target: any) => void;
export function LoggedController(
options: ControllerOptions & { verbose?: boolean }
): (target: any) => void;
export function LoggedController(param?: any): (target: any) => void {
return (target: any) => {
loggerInit(target.prototype);
const logger = target.prototype.logger;
const methods = Object.getOwnPropertyNames(target.prototype);
let verbose =
typeof param === "object" && Object.keys(param).includes("verbose")
? param.verbose
: false;
methods.forEach((method) => {
if (
method !== "constructor" &&
typeof target.prototype[method] === "function"
) {
if (verbose) {
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],
});
export function LoggedController(): (target: any) => void;
export function LoggedController(
prefix: string | string[],
): (target: any) => void;
export function LoggedController(
options: ControllerOptions & { verbose?: boolean },
): (target: any) => void;
export function LoggedController(param?: any): (target: any) => void {
return (target: any) => {
loggerInit(target.prototype);
const logger = target.prototype.logger;
const methods = Object.getOwnPropertyNames(target.prototype);
let verbose =
typeof param === 'object' && Object.keys(param).includes('verbose')
? param.verbose
: false;
methods.forEach((method) => {
if (
method !== 'constructor' &&
typeof target.prototype[method] === 'function'
) {
if (verbose) {
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})`,
);
}
});
Controller(param)(target);
};
}
LoggedRoute()(target.prototype, method, {
value: target.prototype[method],
});
}
});
Controller(param)(target);
};
}

4
src/logged/index.ts
View File

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

12
src/logged/metadata.ts
View File

@ -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,
};
}
}
}

49
src/logged/methods/function.ts
View File

@ -1,16 +1,22 @@
import { Logger } from "@nestjs/common";
import { OverrideBuildOptions, loggerInit } from "../utils";
import { LoggedMetadata, nestLoggedMetadata } from "../metadata";
import { loggedParam, scopedLogger, returns, ReturnsReflectData, LoggedParamReflectData } from "../../reflected";
import { overrideBuild } from "../override";
import { Logger } from '@nestjs/common';
import { OverrideBuildOptions, loggerInit } from '../utils';
import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
import {
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)
return
logMetadata.updateOption(options);
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(
nestLoggedMetadata,
newMetadata,
_target,
key
)
Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
all.forEach(([k, v]) => {
Reflect.defineMetadata(k, v, _target[key]);
Reflect.defineMetadata(k, v, descriptor.value);
});
}
}
};
}

45
src/logged/methods/guard.ts
View File

@ -1,14 +1,18 @@
import { ExecutionContext, Logger } from "@nestjs/common";
import { OverrideBuildOptions, loggerInit } from "../utils";
import { LoggedMetadata, nestLoggedMetadata } from "../metadata";
import { scopedLogger, returns, ReturnsReflectData } from "../../reflected";
import { overrideBuild } from "../override";
import { ExecutionContext, Logger } from '@nestjs/common';
import { OverrideBuildOptions, loggerInit } from '../utils';
import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
import { scopedLogger, returns, ReturnsReflectData } from '../../reflected';
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)
return
logMetadata.updateOption(options);
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(
nestLoggedMetadata,
newMetadata,
_target,
key
)
Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
all.forEach(([k, v]) => {
Reflect.defineMetadata(k, v, _target[key]);
Reflect.defineMetadata(k, v, descriptor.value);
});
}
}
};
}

10
src/logged/methods/index.ts
View File

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

45
src/logged/methods/interceptor.ts
View File

@ -1,15 +1,19 @@
import { OverrideBuildOptions } from "../utils";
import { ExecutionContext, Logger } from "@nestjs/common";
import { loggerInit } from "../utils";
import { OverrideBuildOptions } from '../utils';
import { ExecutionContext, Logger } from '@nestjs/common';
import { loggerInit } from '../utils';
import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
import { scopedLogger, returns, ReturnsReflectData } from "../../reflected";
import { overrideBuild } from "../override";
import { scopedLogger, returns, ReturnsReflectData } from '../../reflected';
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)
return
logMetadata.updateOption(options);
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(
nestLoggedMetadata,
newMetadata,
_target,
key
)
Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
all.forEach(([k, v]) => {
Reflect.defineMetadata(k, v, _target[key]);
Reflect.defineMetadata(k, v, descriptor.value);
});
}
}
};
}

45
src/logged/methods/middleware.ts
View File

@ -1,15 +1,19 @@
import { OverrideBuildOptions } from "../utils";
import { ExecutionContext, Logger } from "@nestjs/common";
import { loggerInit } from "../utils";
import { OverrideBuildOptions } from '../utils';
import { ExecutionContext, Logger } from '@nestjs/common';
import { loggerInit } from '../utils';
import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
import { scopedLogger, returns, ReturnsReflectData } from "../../reflected";
import { overrideBuild } from "../override";
import { scopedLogger, returns, ReturnsReflectData } from '../../reflected';
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)
return
logMetadata.updateOption(options);
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(
nestLoggedMetadata,
newMetadata,
_target,
key
)
Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
all.forEach(([k, v]) => {
Reflect.defineMetadata(k, v, _target[key]);
Reflect.defineMetadata(k, v, descriptor.value);
});
}
}
};
}

61
src/logged/methods/route.ts
View File

@ -1,15 +1,24 @@
import { RequestMethod } from "@nestjs/common";
import { OverrideBuildOptions, loggerInit, RevRequestMethod } from "../utils";
import { LoggedMetadata, nestLoggedMetadata } from "../metadata";
import { loggedParam, scopedLogger, returns, ReturnsReflectData, LoggedParamReflectData } from "../../reflected";
import { overrideBuild } from "../override";
import { createRouteParamDecorator } from "../../internals/nest";
import { RequestMethod } from '@nestjs/common';
import { OverrideBuildOptions, loggerInit, RevRequestMethod } from '../utils';
import { LoggedMetadata, nestLoggedMetadata } from '../metadata';
import {
loggedParam,
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)
return
logMetadata.updateOption(options);
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 httpMethod: RequestMethod = Reflect.getMetadata("method", fn);
const httpPath: string = Reflect.getMetadata('path', 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(
nestLoggedMetadata,
newMetadata,
_target,
key
)
Reflect.defineMetadata(nestLoggedMetadata, newMetadata, _target, key);
all.forEach(([k, v]) => {
Reflect.defineMetadata(k, v, _target[key]);
Reflect.defineMetadata(k, v, descriptor.value);
});
};
}
}

167
src/logged/override.ts
View File

@ -1,9 +1,13 @@
import { Logger, ExecutionContext } from "@nestjs/common";
import { LoggedParamReflectData, ReturnsReflectData } from "../reflected";
import { Logger, ExecutionContext } from '@nestjs/common';
import { LoggedParamReflectData, ReturnsReflectData } from '../reflected';
import { LoggedMetadata } from './metadata';
import { BuildType, REQUEST_LOG_ID, createCallLogIdentifyMessage } from "./utils";
import { objectContainedLogSync, getItemByPathSync } from "../internals/utils";
import { ScopedLogger } from "../logger";
import {
BuildType,
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 =
type === 'middleware' || type === 'guard' || type === 'interceptor' || type === 'route'
const callLogIdentifyMessage =
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
? "WITH " +
metadatas.loggedParams.map(
({ name, index, include, exclude }) =>
name +
"=" +
objectContainedLogSync(args[index], {
include,
exclude,
})
).join(", ")
: ""
}`
`${callLogIdentifyMessage} ${
metadatas.loggedParams && metadatas.loggedParams.length > 0
? 'WITH ' +
metadatas.loggedParams
.map(
({ name, index, include, exclude }) =>
name +
'=' +
objectContainedLogSync(args[index], {
include,
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
? "WITH " +
returnsData.map(({ name, path }) => {
const value = getItemByPathSync(r, path);
? typeof r === 'object' && r !== null
? 'WITH ' +
returnsData
.map(({ name, path }) => {
const value = getItemByPathSync(r, path);
return value !== undefined ? `${name}=${value}` : "";
})
.filter((v) => v.length > 0)
.join(", ")
: ""
return value !== undefined ? `${name}=${value}` : '';
})
.filter((v) => v.length > 0)
.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"
? "WITH " + JSON.stringify(r)
: "WITH " + r
: "";
? typeof r === 'object'
? 'WITH ' + JSON.stringify(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
? "WITH " +
returnsData.map(({ name, path }) => {
const value = getItemByPathSync(r, path);
? typeof r === 'object' && r !== null
? 'WITH ' +
returnsData
.map(({ name, path }) => {
const value = getItemByPathSync(r, path);
return value !== undefined ? `${name}=${value}` : "";
})
.filter((v) => v.length > 0)
.join(", ")
: ""
return value !== undefined ? `${name}=${value}` : '';
})
.filter((v) => v.length > 0)
.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"
? "WITH " + JSON.stringify(r)
: "WITH " + r
: "";
? typeof r === 'object'
? 'WITH ' + JSON.stringify(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;
}
}
}
};
}

53
src/logged/utils.ts
View File

@ -1,22 +1,22 @@
import { Logger, LogLevel } from "@nestjs/common";
import { Logger, LogLevel } from '@nestjs/common';
export const RevRequestMethod = [
"GET",
"POST",
"PUT",
"DELETE",
"PATCH",
"ALL",
"OPTIONS",
"HEAD",
"SEARCH",
'GET',
'POST',
'PUT',
'DELETE',
'PATCH',
'ALL',
'OPTIONS',
'HEAD',
'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.");
Object.defineProperty(_target, "logger", {
newTargetLogger.log('Logger Initialized.');
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')
return `${message} ${callLogIdentifyMessageDictionary[type]} ${key} (${route})`
if (
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,
}
};

49
src/logger.ts
View File

@ -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");
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');
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
)
};
static fromRoot(logger: Logger, scope: string, scopeId?: string): ScopedLogger {
return new ScopedLogger(
logger, [scope], scopeId
)
};
baseLogger,
[...logger.scope, scope],
logger.scopeId,
);
}
static fromRoot(
logger: Logger,
scope: string,
scopeId?: string,
): ScopedLogger {
return new ScopedLogger(logger, [scope], scopeId);
}
static createScopeId(): string {
return createId();
}
}
}

127
src/reflected.ts
View File

@ -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 loggedParam = Symbol("nlogdec-loggedParam");
export const returns = Symbol("nlogdec-returns");
export const scopedLogger = Symbol('nlogdec-scopedLogger');
export const loggedParam = Symbol('nlogdec-loggedParam');
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(
...pipes: Pipe[]
): LoggedParamReturns;
export function LoggedParam(...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)(
property,
...pipes,
)(
createPipesRouteParamDecorator(RouteParamtypes.PARAM)(property, ...pipes)(
target,
propertyKey,
parameterIndex,
@ -109,15 +117,13 @@ export function LoggedParam(
target,
propertyKey,
parameterIndex,
)
}
}
);
};
};
}
export function LoggedQuery(): LoggedParamReturns;
export function LoggedQuery(
...pipes: Pipe[]
): LoggedParamReturns;
export function LoggedQuery(...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)(
property, ...pipes
)(
target, propertyKey, parameterIndex,
createPipesRouteParamDecorator(RouteParamtypes.QUERY)(property, ...pipes)(
target,
propertyKey,
parameterIndex,
);
createLoggedFunctionParam(name, options)(
target, propertyKey, parameterIndex,
target,
propertyKey,
parameterIndex,
);
}
}
};
};
}
export function LoggedBody(): LoggedParamReturns;
export function LoggedBody(
...pipes: Pipe[]
): LoggedParamReturns;
export function LoggedBody(...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)(
property,
...pipes,
)(
target, propertyKey, parameterIndex
createPipesRouteParamDecorator(RouteParamtypes.BODY)(property, ...pipes)(
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?: {
[name: string]: string;
} | string) {
export function Returns<F extends Array<any>, R>(
namePaths?:
| {
[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,
);
};
}

184
src/test/index.ts
View File

@ -1,10 +1,6 @@
import { LoggedFunction, LoggedInjectable } from "../logged";
import { ScopedLogger } from "../logger";
import {
InjectLogger,
Logged,
Returns,
} from "../reflected";
import { LoggedFunction, LoggedInjectable } from '../logged';
import { ScopedLogger } from '../logger';
import { 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(
private service: TestService
) { }
constructor(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("key2") key2: string
@Logged('key') key: number,
@Logged('key2') key2: string,
) {
console.log(key, key2);
}
async testParameterLoggingWithInjection(
@Logged("key") key: number,
@InjectLogger logger?: ScopedLogger
@Logged('key') key: number,
@InjectLogger logger?: ScopedLogger,
) {
logger.log(key.toString());
}
async testMultiParameterLoggingWithInjection(
@Logged("key") key: number,
@Logged("key2") key2: string,
@InjectLogger logger?: ScopedLogger
@Logged('key') key: number,
@Logged('key2') key2: string,
@InjectLogger logger?: ScopedLogger,
) {
logger.log(key.toString() + key2);
}
async testObjectParameterLogging(
@Logged("key") key: TestObject,
@InjectLogger logger?: ScopedLogger
@Logged('key') key: TestObject,
@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')
return 2
logger.log('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(
private service: TestService
) { }
constructor(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("key2") key2: string
@Logged('key') key: number,
@Logged('key2') key2: string,
) {
console.log(key, key2);
}
@LoggedFunction()
async testParameterLoggingWithInjection(
@Logged("key") key: number,
@InjectLogger logger?: ScopedLogger
@Logged('key') key: number,
@InjectLogger logger?: ScopedLogger,
) {
logger.log(key.toString());
}
@LoggedFunction()
async testMultiParameterLoggingWithInjection(
@Logged("key") key: number,
@Logged("key2") key2: string,
@InjectLogger logger?: ScopedLogger
@Logged('key') key: number,
@Logged('key2') key2: string,
@InjectLogger logger?: ScopedLogger,
) {
logger.log(key.toString() + key2);
}
@LoggedFunction()
async testObjectParameterLogging(
@Logged("key") key: TestObject,
@InjectLogger logger?: ScopedLogger
@Logged('key') key: TestObject,
@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')
return 2
logger.log('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();
/**

10
src/utils.ts
View File

@ -1,9 +1,9 @@
import { Logger } from "@nestjs/common";
import { ScopedLogger } from "./logger";
import { REQUEST_LOG_ID } from "./logged/utils";
import { Logger } from '@nestjs/common';
import { ScopedLogger } from './logger';
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]);
}

10
yarn.lock
View File

@ -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"