Typescript 데코레이터로 NestJS처럼 Logger와 Validator 구현하기

{
  "compilerOptions": {
    "experimentalDecorators": true
  }
}

// simple-decorator.ts
 
export function SimpleDecorator(
  target: any, // 클래스 프로토타입 또는 생성자 함수
  propertyKey?: string, // 속성 또는 메서드 이름
  descriptor?: PropertyDescriptor | number, // 속성 설명자 또는 매개변수 인덱스
) {
  console.log('====================================================');
  console.log('Target', target);
  console.log('Property Key', propertyKey);
  console.log('Descriptor', descriptor);
}

// example.ts
 
import { SimpleDecorator } from './simple-decorator';
 
@SimpleDecorator
class Example {
  @SimpleDecorator
  private _myProperty01: string = '';
 
  @SimpleDecorator
  get property() {
    return this._myProperty01;
  }
 
  @SimpleDecorator
  foo(
    @SimpleDecorator
    name: string,
    @SimpleDecorator
    age: number,
  ) {
    return `Name: ${name}, Age: ${age}`;
  }
}

// 메서드 데코레이터 출력결과
// Target {}
// Property Key foo
// Descriptor {
//   value: [Function: foo],
//   writable: true,
//   enumerable: false,
//   configurable: true
// }

export interface LoggerOptions {
  mode: 'simple' | 'detailed';
}
 
export function Logger({ mode }: LoggerOptions = { mode: 'simple' }) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
 
    descriptor.value = function (...args: any[]) {
      console.log(`${propertyKey}를 호출합니다.`);
      if (mode === 'detailed') {
        console.log('매개변수:', args);
      }
 
      const result = originalMethod.apply(this, args);
 
      console.log(`${propertyKey} 호출이 완료되었습니다`);
      if (mode === 'detailed') {
        console.log('반환값:', result);
      }
 
      return result;
    };
 
    return descriptor;
  };
}

import { Logger } from './logger';
 
class Example2 {
  @Logger({ mode: 'detailed' })
  foo(name: string, age: number) {
    return `Name: ${name}, Age: ${age}`;
  }
}
 
const example2 = new Example2();
const returnValue = example2.foo('Ina', 20);
console.log(returnValue); // Name: Ina, Age: 20
 
// foo를 호출합니다.
// 매개변수: [ 'Ina', 20 ]
// foo 호출이 완료되었습니다
// 반환값: Name: Ina, Age: 20

import 'reflect-metadata';
 
export interface MinLength {
  length: number;
  message?: string;
}
 
/**
 * 메타 정보를 저장하는 경우 Reflect API를 활용할 수 있다.
 * reflect-metadata 패키지를 설치하고 import 해야 한다.
 */
export function MinLength({ length, message = '최소 길이는 ${length}입니다.' }: MinLength) {
  return function (target: any, propertyKey: string) {
    // 유효성 검사에 사용할 메타데이터 정의
    const constraint = { value: length, message };
 
    // Reflect API를 사용해 메타데이터 저장
    Reflect.defineMetadata('minLength', constraint, target, propertyKey);
  };
}

 
npm install reflect-metadata

import 'reflect-metadata';
 
export function validate(target: any) {
  // 대상 객체의 각 속성에 대해 메타데이터 확인 및 유효성 검사 수행
  for (const propertyKey of Object.keys(target)) {
    // Reflect API를 사용해 유효성 검사를 위한 메타데이터 조회
    const constraint = Reflect.getMetadata('minLength', target, propertyKey);
 
    // 유효성 검사 메타데이터가 존재한다면,
    if (constraint) {
      const value = target[propertyKey];
 
      // 유효성 검사 수행
      if (typeof value === 'string' && value.length < constraint.value) {
        const errorMessage = constraint.message.replace('${length}', constraint.value.toString());
 
        console.log(errorMessage);
        throw new Error(errorMessage);
      }
    }
  }
 
  console.log('유효성 검사를 통과했습니다.');
}

import { MinLength, validate } from './validator';
 
class Example {
  @MinLength({ length: 3, message: '이름은 최소 ${length}자 이상이어야 합니다.' })
  value: string;
 
  constructor(value: string) {
    this.value = value;
  }
}
 
const example1 = new Example('Ina');
validate(example1); // 유효성 검사를 통과했습니다.
 
const example2 = new Example('MO');
validate(example2); // ERROR! 이름은 최소 3자 이상이어야 합니다.