import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as dotenv from 'dotenv';
import * as path from 'path';

// dotenv 패키지 직접 사용
dotenv.config({
  path: path.resolve(
          process.env.NODE_ENV === 'dev'
                  ? '.dev.env'
                  : process.env.NODE_ENV === 'stage'
                          ? '.stage.env'
                          : '.local.env',
  ),
});
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

  @Get('env')
  getEnv(): string {
    return process.env.DATABASE_HOST;
  }

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [ConfigModule.forRoot()],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

/**
 * Loads process environment variables depending on the "ignoreEnvFile" flag and "envFilePath" value.
 * Also, registers custom configurations globally.
 * @param options
 */
static forRoot(options?: ConfigModuleOptions): DynamicModule;
/**
 * Registers configuration object (partial registration).
 * @param config
 */
static forFeature(config: ConfigFactory): DynamicModule;

export interface ConfigModuleOptions {
    /**
     * If "true", values from the process.env object will be cached in the memory.
     * This improves the overall application performance.
     * See: https://github.com/nodejs/node/issues/3104
     */
    cache?: boolean;
    /**
     * If "true", registers `ConfigModule` as a global module.
     * See: https://docs.nestjs.com/modules#global-modules
     */
    isGlobal?: boolean;
    /**
     * If "true", environment files (`.env`) will be ignored.
     */
    ignoreEnvFile?: boolean;
    /**
     * If "true", predefined environment variables will not be validated.
     */
    ignoreEnvVars?: boolean;
    /**
     * Path to the environment file(s) to be loaded.
     */
    envFilePath?: string | string[];
    /**
     * Environment file encoding.
     */
    encoding?: string;
    /**
     * Custom function to validate environment variables. It takes an object containing environment
     * variables as input and outputs validated environment variables.
     * If exception is thrown in the function it would prevent the application from bootstrapping.
     * Also, environment variables can be edited through this function, changes
     * will be reflected in the process.env object.
     */
    validate?: (config: Record<string, any>) => Record<string, any>;
    /**
     * Environment variables validation schema (Joi).
     */
    validationSchema?: any;
    /**
     * Schema validation options.
     * See: https://joi.dev/api/?v=17.3.0#anyvalidatevalue-options
     */
    validationOptions?: Record<string, any>;
    /**
     * Array of custom configuration files to be loaded.
     * See: https://docs.nestjs.com/techniques/configuration
     */
    load?: Array<ConfigFactory>;
    /**
     * A boolean value indicating the use of expanded variables, or object
     * containing options to pass to dotenv-expand.
     * If .env contains expanded variables, they'll only be parsed if
     * this property is set to true.
     */
    expandVariables?: boolean | DotenvExpandOptions;
}

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath:
        process.env.NODE_ENV === 'dev'
          ? '.dev.env'
          : process.env.NODE_ENV === 'stage'
          ? '.stage.env'
          : '.local.env',
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Controller, Get } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Controller()
export class AppController {
  constructor(
          private readonly configService: ConfigService,
  ) {}

  @Get('config')
  getConfig(): string {
    return this.configService.get('DATABASE_HOST');
  }
}

import { registerAs } from '@nestjs/config';

// 'email' 이라는 토큰으로 ConfigFactory 를 등록할 수 있는 함수
export default registerAs('email', () => ({
  service: process.env.EMAIL_SERVICE,
  auth: {
    user: process.env.EMAIL_AUTH_USER,
    pass: process.env.EMAIL_AUTH_PASSWORD,
  },
  baseUrl: process.env.EMAIL_BASE_URL,
}));

import * as Joi from 'joi';

export const validationSchema = Joi.object({
  EMAIL_SERVICE: Joi.string().required(),
  EMAIL_AUIH_USER: Joi.string().required(),
  EMAIL_AUTH_PASSWORD: Joi.string().required(),
  EMAIL_BASE_URL: Joi.string().required().uri(),
});

import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';
import { ConfigModule } from '@nestjs/config';
import emailConfig from './config/emailConfig';
import { validationSchema } from './config/validationSchema';

@Module({
  imports: [
    UsersModule,
    ConfigModule.forRoot({
      envFilePath: [`${__dirname}/config/env/.${process.env.NODE_ENV}.env`],
      load: [emailConfig], // ConfigFactory 지정
      isGlobal: true, // 전역으로 등록해서 어느 모듈에서나 사용 가능
      validationSchema, // 환경 변수 값에 대해 유효성 검사 수행
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

import { Inject, Injectable } from '@nestjs/common';
import Mail from 'nodemailer/lib/mailer';
import * as nodemailer from 'nodemailer';
import emailConfig from '../config/emailConfig';
import { ConfigType } from '@nestjs/config';

interface EmailOptions {
  to: string;
  subject: string;
  html: string;
}
@Injectable()
export class EmailService {
  private transporter: Mail;

  // constructor() {
  //   this.transporter = nodemailer.createTransport({
  //     service: 'Gmail',
  //     auth: {
  //       user: 'test@gmail.com',
  //       pass: 'aaaaa',
  //     },
  //   });
  // }

  constructor(
    // 주입받을 때 @Inject 데커레이터의 토큰을 앞에서 만든 ConfigFactory 의 KEY 인 `email` 문자열로 넣어준다.
    @Inject(emailConfig.KEY) private config: ConfigType<typeof emailConfig>,
  ) {
    this.transporter = nodemailer.createTransport({
      service: config.service, // env 파일에 있는 값들
      auth: {
        user: config.auth.user,
        pass: config.auth.pass,
      },
    });
  }

  // 가입 인증 메일 발송
  async sendMemberJoinVerification(email: string, signupVerifyToken: string) {
    const baseUrl = this.config.baseUrl;
    const url = `${baseUrl}/users/email-verify?signupVerifyToken=${signupVerifyToken}`;
    const mailOptions: EmailOptions = {
      to: email,
      subject: '가입 인증 메일',
      html: `가입확인 버튼를 누르시면 가입 인증이 완료됩니다.<br />
        <form action="${url}" method="POST">
          <button>가입확인</button>
        </form>`,
    };

    return await this.transporter.sendMail(mailOptions);
  }
}