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

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'secret',
      database: 'myapp_dev',
      entities: [],
      synchronize: true, // ⚠️ Тільки для розробки!
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

TypeOrmModule.forRoot({
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'postgres',
  password: 'secret', // ⚠️ Хардкод паролю — погана практика!
  database: 'myapp_dev',
  entities: [__dirname + '/**/*.entity{.ts,.js}'],
  synchronize: true,
  logging: true,
})

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true, // ConfigService доступний у всіх модулях
      envFilePath: '.env',
    }),
    TypeOrmModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: (configService: ConfigService) => ({
        type: 'postgres',
        host: configService.get<string>('DB_HOST'),
        port: configService.get<number>('DB_PORT'),
        username: configService.get<string>('DB_USERNAME'),
        password: configService.get<string>('DB_PASSWORD'),
        database: configService.get<string>('DB_DATABASE'),
        entities: [__dirname + '/**/*.entity{.ts,.js}'],
        synchronize: configService.get<boolean>('DB_SYNCHRONIZE', false),
        logging: configService.get<boolean>('DB_LOGGING', false),
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

import { Injectable } from '@nestjs/common';
import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class DatabaseConfig implements TypeOrmOptionsFactory {
  constructor(private configService: ConfigService) {}

  createTypeOrmOptions(): TypeOrmModuleOptions {
    const isProduction = this.configService.get('NODE_ENV') === 'production';

    return {
      type: 'postgres',
      host: this.configService.get('DB_HOST'),
      port: this.configService.get('DB_PORT'),
      username: this.configService.get('DB_USERNAME'),
      password: this.configService.get('DB_PASSWORD'),
      database: this.configService.get('DB_DATABASE'),
      entities: [__dirname + '/../**/*.entity{.ts,.js}'],
      
      // Різні налаштування для dev і production
      synchronize: !isProduction, // FALSE у production!
      logging: !isProduction ? ['query', 'error'] : ['error'],
      
      // SSL обов'язковий у production
      ssl: isProduction ? { rejectUnauthorized: false } : false,
      
      // Connection pool налаштування
      extra: {
        max: isProduction ? 20 : 10,
        connectionTimeoutMillis: 2000,
      },
    };
  }
}

import { DatabaseConfig } from './config/database.config';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    TypeOrmModule.forRootAsync({
      useClass: DatabaseConfig, // Використовуємо кастомний клас
    }),
  ],
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './entities/user.entity';
import { UsersService } from './users.service';

@Module({
  imports: [
    TypeOrmModule.forFeature([User]), // Реєстрація Entity
  ],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

import { MigrationInterface, QueryRunner } from 'typeorm';

export class AddAgeToUsers1699000001000 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`
      ALTER TABLE "users" ADD "age" integer
    `);
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`
      ALTER TABLE "users" DROP COLUMN "age"
    `);
  }
}

# Середовище виконання
NODE_ENV=development

# База даних
DB_HOST=localhost
DB_PORT=5432
DB_USERNAME=postgres
DB_PASSWORD=secret_password_here
DB_DATABASE=myapp_dev
DB_SYNCHRONIZE=true
DB_LOGGING=true

# Додаткові налаштування
PORT=3000

# Environment variables
.env
.env.local
.env.production

# Dependencies
node_modules/

# Build output
dist/

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,      // Доступний у всіх модулях
      envFilePath: '.env', // Шлях до .env файлу
      cache: true,         // Кешувати змінні для продуктивності
    }),
  ],
})
export class AppModule {}

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class UsersService {
  constructor(private configService: ConfigService) {
    const dbHost = this.configService.get<string>('DB_HOST');
    const dbPort = this.configService.get<number>('DB_PORT');
    
    console.log(`Database: ${dbHost}:${dbPort}`);
  }
}

import * as Joi from 'joi';

export const envValidationSchema = Joi.object({
  NODE_ENV: Joi.string()
    .valid('development', 'production', 'test', 'staging')
    .default('development'),
  
  PORT: Joi.number().default(3000),
  
  DB_HOST: Joi.string().required(),
  DB_PORT: Joi.number().default(5432),
  DB_USERNAME: Joi.string().required(),
  DB_PASSWORD: Joi.string().required(),
  DB_DATABASE: Joi.string().required(),
  DB_SYNCHRONIZE: Joi.boolean().default(false),
  DB_LOGGING: Joi.boolean().default(false),
});

import { envValidationSchema } from './config/env.validation';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: envValidationSchema,
      validationOptions: {
        abortEarly: true, // Зупинитися на першій помилці
        allowUnknown: true, // Дозволити невідомі змінні
      },
    }),
  ],
})
export class AppModule {}

ConfigModule.forRoot({
  isGlobal: true,
  envFilePath: `.env.${process.env.NODE_ENV || 'development'}`,
  validationSchema: envValidationSchema,
})

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    container_name: myapp_postgres
    restart: unless-stopped
    ports:
      - '5432:5432'
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: myapp_dev
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - myapp_network
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U postgres']
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres_data:
    driver: local

networks:
  myapp_network:
    driver: bridge

version: '3.8'

services:
  postgres:
    # ... (конфігурація вище)

  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: myapp_nestjs
    restart: unless-stopped
    ports:
      - '3000:3000'
    environment:
      DB_HOST: postgres  # ⚠️ Назва сервісу, а не localhost!
      DB_PORT: 5432
      DB_USERNAME: postgres
      DB_PASSWORD: secret
      DB_DATABASE: myapp_dev
    depends_on:
      postgres:
        condition: service_healthy  # Чекати, поки PostgreSQL готовий
    networks:
      - myapp_network

volumes:
  postgres_data:

networks:
  myapp_network:

POSTGRES_USER=postgres
POSTGRES_PASSWORD=secret
POSTGRES_DB=myapp_dev

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}

import { Module, OnModuleInit } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { DataSource } from 'typeorm';

@Module({
  imports: [
    // ... TypeOrmModule.forRootAsync()
  ],
})
export class AppModule implements OnModuleInit {
  constructor(private dataSource: DataSource) {}

  async onModuleInit() {
    try {
      if (this.dataSource.isInitialized) {
        console.log('✅ Database connection established successfully');
        
        // Додаткова інформація про з'єднання
        const { host, port, database } = this.dataSource.options as any;
        console.log(`📦 Connected to: ${host}:${port}/${database}`);
        
        // Перевірка версії PostgreSQL
        const result = await this.dataSource.query('SELECT version()');
        console.log(`🐘 PostgreSQL version: ${result[0].version.split(' ')[1]}`);
      }
    } catch (error) {
      console.error('❌ Database connection failed:', error.message);
      process.exit(1); // Критична помилка — зупиняємо застосунок
    }
  }
}

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Graceful shutdown при отриманні SIGTERM/SIGINT
  app.enableShutdownHooks();

  await app.listen(3000);
  console.log(`🚀 Application is running on: ${await app.getUrl()}`);
}

bootstrap();

import { Module, OnApplicationShutdown } from '@nestjs/common';
import { DataSource } from 'typeorm';

@Module({
  // ...
})
export class AppModule implements OnApplicationShutdown {
  constructor(private dataSource: DataSource) {}

  async onApplicationShutdown(signal?: string) {
    console.log(`⚠️  Received shutdown signal: ${signal}`);
    
    if (this.dataSource.isInitialized) {
      await this.dataSource.destroy();
      console.log('✅ Database connection closed');
    }
  }
}