typeORM 시간대 설정에 관한 고찰 - typeORM의 dateStrings와 timezone 옵션에 따른 시간대 혼란

// UTC로 받은 시간 문자열
const utcDate = '2024-03-02T12:00:00Z';

// 로컬 시간대로 변환
const localDate = new Date(utcDate).toLocaleString('ko-KR', { timeZone: 'Asia/Seoul' });

console.log(localDate); // 변환된 로컬 시간 출력

// 애플리케이션 서버의 타임존을 고려하여 Date타입을 재가공 
// (ex. 2021-08-01T00:00:00.000Z -> 2021-08-01 00:00:00)
public formatDate(date: Date): string {
 const localDateTime: Date = new Date(
    			        date.getTime() - date.getTimezoneOffset() * 60 * 1000
    			      );
    			  
    			      return localDateTime.toISOString().substring(0, 19).replace('T', ' ');
    			    }

class DateUtils {  
  public static formatDate(date: Date): string {  
    const localDateTime: Date = new Date(  
      date.getTime() - date.getTimezoneOffset() * 60 * 1000  
    );  
  
    return localDateTime.toISOString().substring(0, 19).replace('T', ' ');  
  }
}

class UserService {
  async getUser(targetId: number): Promise<ExtendedUser> {
    const result = await UserRepository.findOne( {where: {id: targetId} } );
    if (!result) {
      return null; // 사용자를 찾을 수 없는 경우
    }
    return {
      ...result,
      created_at: DateUtils.formatDate(user.created_at),
      updated_at: DateUtils.formatDate(user.updated_at),
      // deleted_at은 선택적 필드이므로, 존재할 때만 변환
      deleted_at: user.deleted_at ? DateUtils.formatDate(user.deleted_at) : null,
    };

  async getUsers(condition: any): Promise<ExtendedUser[]> {
	const result = await SomeRepository.find(condition);
	return result.map((data: User) => ({
	 ...data, 
	 created_at: DateUtils.formatDate(data.created_at),
	 updated_at: DateUtils.formatDate(data.updated_at),
	 deleted_at: data.deleted_at ? DateUtils.formatDate(data.deleted_at) : null, }));  
  }  
}

import { DateUtils } from '../utils/dateUtils';  
  
export const dateTransformer: ValueTransformer = {  
  from: (value: Date) =>  
    value instanceof Date ? DateUtils.formatDate(value) : value,  
  to: (value: Date) => value,  
};  
  
export abstract class Base extends BaseEntity {  
  @PrimaryGeneratedColumn()  
  id!: number;  
  
  @CreateDateColumn({ type: 'timestamp', transformer: dateTransformer })  
  created_at!: Date;  
  
  @UpdateDateColumn({ type: 'timestamp', transformer: dateTransformer })  
  updated_at!: Date;  
  
  @DeleteDateColumn({ type: 'timestamp', transformer: dateTransformer })  
  deleted_at?: Date | null;  
}

// '/global' 경로를 포함하는 요청에 대한 미들웨어 추가 (최상단 위치시킬 것)
router.use((req, res, next) => { 
// 요청 경로가 '/global'로 시작하는지 확인 
req.global = req.path.startsWith('/global'); 
next(); 
});

// 이후 router.use 코드들...

export class DateUtils {  
    const localDateTime: Date = new Date(  
      date.getTime() - date.getTimezoneOffset() * 60 * 1000  
    );  
  
    return localDateTime.toISOString().substring(0, 19).replace('T', ' ');  
  }  
  
  // DB에서 가져오는 반환 값 중 Date 타입의 모든 값을 formatDate 함수로 처리해주는 함수  
  // typeORM Entities의 options 중 transformer를 사용하지 않고 service 로직에서 처리를 할 때 사용  
  public static async processDateValues(result: any): Promise<any> {  
    // 쿼리 실행 후에 반환된 결과를 가공  
    if (Array.isArray(result)) {  
      // 반환된 결과가 배열인 경우  
      return result.map(item => this.processItem(item));  
    } else {  
      // 반환된 결과가 단일 객체인 경우  
      return this.processItem(result);  
    }  
  }  
  
  private static processItem(item: any): any {  
    // 객체의 모든 속성을 순회하면서 Date 타입인 경우에만 가공  
    for (const key in item) {  
      if (item.hasOwnProperty(key) && item[key] instanceof Date) {  
        item[key] = DateUtils.formatDate(item[key]);  
      } else if (typeof item[key] === 'object') {  
        // 객체인 경우 재귀적으로 processItem 호출  
        item[key] = this.processItem(item[key]);  
      }  
    }  
    return item;  
  }  
}

class SomeService {
  async processData(req) {
    const result = await someRepository.find();

    // 요청 경로에 '/global'이 포함되어 있지 않은 경우에만 데이터 변환 적용
    if (!req.isGlobal) {
      return DateUtils.processDateValues(result);
    }
    return result;
  }
}