import ...

@Injectable()
export class InterceptorExample implements NestInterceptor {
	// 요청이 들어올 때와 응답이 나갈 때 타임스탬프를 찍는 로그 기능
	intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> {
		const now = new Date();  // 현재 시각
		const req = context.switchToHttp().getRequest();  // req 객체 가져오기
		const path = req.originalUrl;  // 요청이 들어온 url

		// 요청 로그 형식: [REQ] {요청 path} {요청 시간}
		console.log(`[REQ] ${path} ${now.toLocaleString('kr')}`);
		// 이 위에까지는 서버 라우트(Controller) 메소드들이 실행되기 전에, 즉 요청이 들어오자마자 실행됨

		// return next.handle()을 실행하는 순간 라우트의 로직이 전부 실행되고 응답이 Observable로 반환
		return next
			.handle()
			.pipe(  // pipe에는 우리가 원하는 RxJS에서 지원하는 모든 함수를 넣어줄 수 있고 함수들은 순서대로 실행
				tap(  // pipe 함수 안에서 순서가 tab() 함수를 지나갈 때마다 전달되는 값들을 모니터링 할 수 있음
					(observable) => {  // 가장 처음에 한 tap의 파라미터로 들어온 observable은 응답
						console.log(observable);  // 라우트 로직을 지나서 생성된 응답이 console.log()로 출력됨
					}
				), 
				map(  // 응답 내용을 변형할 때 사용하는 map (tap은 변형은 못함)
					(observable) => {
						return {  // return 해주는 것이 실제 응답으로 들어가는 것
							message: "응답이 변경 됐습니다."
							response: observable
					}
				), 
				tap(  // 응답이 변형된 후 다시 출력
					(observable) => {
						console.log(observable);
					}
				),
			);
	}
}

@Get()
@UseInterceptors(InterceptorExample)
getPosts() {
	return this.postsService.findAll();
}

// interceptor/log.interceptor.ts
import ...

@Injectable()
export class LogInterceptor implements NestInterceptor {
	intercept(
		context: ExecutionContext,
		next: CallHandler<any>,
	): Observable<any> {
		const now = new Date();
		const req = context.switchToHttp().getRequest();
		const path = req.originalUrl;
		const method = req.method;

		const randomId = getRandomId();
		const reqString = `${LogColorCode.blue}[REQ - ${randomId}]${LogColorCode.reset}`;
		const pathString = `${LogColorCode.leaf}[${method} ${path}]${LogColorCode.reset}`;
		const reqTimeString = `${LogColorCode.warmgray}[${now.toLocaleString(
			'kr',
		)}]${LogColorCode.reset}`;
		let userString: string;

		let reqLog = `${reqString} ${pathString} ${reqTimeString}`;
		if (req.user) {
			userString = `${LogColorCode.purple}[${req.user.username}]${LogColorCode.reset}`;
			reqLog += ` ${userString}`;
		}
		Logger.log(reqLog);

		return next.handle().pipe(
			catchError((error) => {
				const errTime = new Date();
				const errString = `${LogColorCode.red}[ERR - ${randomId}]${LogColorCode.reset}`;
				const errTimeString = `${
					LogColorCode.warmgray
				}[${errTime.toLocaleString('kr')} - ${
					errTime.getMilliseconds() - now.getMilliseconds()
				}ms]${LogColorCode.reset}`;

				let errLog = `${errString} ${pathString} ${errTimeString}`;
				if (req.user) {
					errLog += ` ${userString}`;
				}
				Logger.error(errLog);
				Logger.error(error);
				throw error;
			}),
			tap(() => {
				const resTime = new Date();
				const resString = `${LogColorCode.orange}[RES - ${randomId}]${LogColorCode.reset}`;
				const resTimeString = `${
					LogColorCode.warmgray
				}[${resTime.toLocaleString('kr')} - ${
					resTime.getMilliseconds() - now.getMilliseconds()
				}ms]${LogColorCode.reset}`;

				let resLog = `${resString} ${pathString} ${resTimeString}`;
				if (req.user) {
					resLog += ` ${userString}`;
				}
				Logger.log(resLog);
			}),
		);
	}
}

// interceptor/transaction.interceptor.ts
import ...

@Injectable()
export class TransactionInterceptor implements NestInterceptor {
	constructor(private readonly dataSource: DataSource) {}

	async intercept(
		context: ExecutionContext,
		next: CallHandler<any>,
	): Promise<Observable<any>> {
		const req = context.switchToHttp().getRequest();
		const path = req.originalUrl;
		const method = req.method;

		const queryRunner: QueryRunner = this.dataSource.createQueryRunner();
		await queryRunner.connect();
		await queryRunner.startTransaction();

		const startTime = new Date();
		const randomId = getRandomId();

		const transactionString = `${LogColorCode.orange}[Transaction - ${randomId}]${LogColorCode.reset}`;
		const pathString = `${LogColorCode.leaf}[${method} ${path}]${LogColorCode.reset}`;
		const startTimeString = `${
			LogColorCode.warmgray
		}[${startTime.toLocaleString('kr')}]${LogColorCode.reset}`;
		const transactionMentString = `- ${LogColorCode.orange}Transaction Start${LogColorCode.reset}`;

		const transactionStartLog = `${transactionString} ${pathString} ${startTimeString} ${transactionMentString}`;
		Logger.log(transactionStartLog);
		req.queryRunner = queryRunner;

		return next.handle().pipe(
			catchError(async (error) => {
				await queryRunner.rollbackTransaction();
				await queryRunner.release();

				const rollbackTime = new Date();
				const rollbackString = `${LogColorCode.red}[Transaction - ${randomId}]${LogColorCode.reset}`;
				const rollbackTimeString = `${
					LogColorCode.warmgray
				}[${rollbackTime.toLocaleString('kr')}]${LogColorCode.reset}`;
				const rollbackMentString = `- ${LogColorCode.red}Transaction Rollback${LogColorCode.reset}`;

				const rollbackLog = `${rollbackString} ${pathString} ${rollbackTimeString} ${rollbackMentString}`;
				Logger.error(rollbackLog);
				Logger.error(error);
				throw new InternalServerErrorException("Can't process your request");
			}),
			tap(async () => {
				await queryRunner.commitTransaction();
				await queryRunner.release();

				const commitTime = new Date();
				const commitString = `${LogColorCode.aqua}[Transaction - ${randomId}]${LogColorCode.reset}`;
				const commitTimeString = `${
					LogColorCode.warmgray
				}[${commitTime.toLocaleString('kr')} - ${
					startTime.getMilliseconds() - commitTime.getMilliseconds()
				}ms]${LogColorCode.reset}`;
				const commitMentString = `- ${LogColorCode.aqua}Transaction Commit${LogColorCode.reset}`;

				const commitLog = `${commitString} ${pathString} ${commitTimeString} ${commitMentString}`;
				Logger.log(commitLog);
			}),
		);
	}
}