{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "moduleResolution": "node",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

import { Client } from 'pg';

async function singleConnectionExample() {
  const client = new Client({
    host: 'localhost',
    port: 5432,
    user: 'postgres',
    password: 'secret',
    database: 'myapp_dev',
  });

  await client.connect(); // Відкриття з'єднання
  console.log('З\'єднання встановлено');

  try {
    const result = await client.query('SELECT NOW()');
    console.log('Час на сервері БД:', result.rows[0].now);
  } finally {
    await client.end(); // Обов'язкове закриття!
  }
}

singleConnectionExample();

import { Pool } from 'pg';

const pool = new Pool({
  host: 'localhost',
  port: 5432,
  user: 'postgres',
  password: 'secret',
  database: 'myapp_dev',
  max: 20, // Максимум 20 одночасних з'єднань
  idleTimeoutMillis: 30000, // Закривати неактивні з'єднання через 30 сек
  connectionTimeoutMillis: 2000, // Таймаут очікування вільного з'єднання
});

async function poolExample() {
  // Pool автоматично надає вільне з'єднання
  const result = await pool.query('SELECT COUNT(*) FROM users');
  console.log('Кількість користувачів:', result.rows[0].count);

  // З'єднання автоматично повертається в пул після завершення
}

poolExample();

import { Pool } from 'pg';

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
});

import { PoolConfig } from 'pg';

const config: PoolConfig = {
  host: 'localhost',           // Адреса сервера БД
  port: 5432,                  // Порт PostgreSQL (за замовчуванням 5432)
  user: 'app_user',            // Ім'я користувача БД
  password: 'secure_password', // Пароль
  database: 'myapp_production', // Назва бази даних
  
  // Налаштування пулу
  max: 20,                     // Макс. кількість з'єднань у пулі
  min: 5,                      // Мін. кількість підтримуваних з'єднань
  idleTimeoutMillis: 30000,    // Закривати неактивні з'єднання через 30 сек
  connectionTimeoutMillis: 2000, // Таймаут очікування доступного з'єднання
  
  // SSL (для production)
  ssl: {
    rejectUnauthorized: false, // Для самопідписаних сертифікатів
  },
};

import { Pool } from 'pg';
import * as fs from 'fs';

const pool = new Pool({
  host: 'db.example.com',
  port: 5432,
  user: 'app_user',
  password: process.env.DB_PASSWORD,
  database: 'production_db',
  ssl: {
    rejectUnauthorized: true, // Вимагати валідний сертифікат
    ca: fs.readFileSync('./certs/ca-certificate.crt').toString(), // Кореневий CA
    key: fs.readFileSync('./certs/client-key.pem').toString(),    // Приватний ключ клієнта
    cert: fs.readFileSync('./certs/client-cert.pem').toString(),  // Сертифікат клієнта
  },
});

import { Pool } from 'pg';

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

async function testConnection() {
  try {
    const client = await pool.connect();
    console.log('✅ З\'єднання успішно встановлено');
    
    const result = await client.query('SELECT current_database(), version()');
    console.log('Поточна база:', result.rows[0].current_database);
    console.log('Версія PostgreSQL:', result.rows[0].version);
    
    client.release(); // Повертаємо з'єднання у пул
  } catch (error) {
    if (error instanceof Error) {
      console.error('❌ Помилка підключення:', error.message);
      
      // Аналіз типу помилки
      if (error.message.includes('ENOTFOUND')) {
        console.error('Сервер БД недоступний. Перевірте host та DNS.');
      } else if (error.message.includes('authentication failed')) {
        console.error('Невірні credentials (user/password).');
      } else if (error.message.includes('ECONNREFUSED')) {
        console.error('PostgreSQL не запущено або не слухає на вказаному порту.');
      }
    }
    process.exit(1); // Зупиняємо процес при критичній помилці
  }
}

testConnection();

import { Pool } from 'pg';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });

async function getAllUsers() {
  const result = await pool.query('SELECT id, email, created_at FROM users');
  
  console.log('Знайдено користувачів:', result.rowCount);
  
  result.rows.forEach(user => {
    console.log(`ID: ${user.id}, Email: ${user.email}`);
  });
}

getAllUsers();

async function getUserByEmail(email: string) {
  const query = 'SELECT id, email, created_at FROM users WHERE email = $1';
  const values = [email];
  
  const result = await pool.query(query, values);
  
  if (result.rowCount === 0) {
    console.log('Користувача не знайдено');
    return null;
  }
  
  return result.rows[0];
}

// Використання:
const user = await getUserByEmail('test@example.com');

async function createUser(email: string, name: string, age: number) {
  const query = `
    INSERT INTO users (email, name, age, created_at)
    VALUES ($1, $2, $3, NOW())
    RETURNING id, email, created_at
  `;
  const values = [email, name, age];
  
  const result = await pool.query(query, values);
  return result.rows[0]; // Повертає вставлений рядок
}

const newUser = await createUser('john@example.com', 'John Doe', 28);
console.log('Створено користувача з ID:', newUser.id);

interface User {
  id: number;
  email: string;
  created_at: Date;
  metadata: { role: string; verified: boolean };
}

async function getUsersWithMetadata(): Promise<User[]> {
  const result = await pool.query<User>(`
    SELECT id, email, created_at, metadata
    FROM users
    WHERE metadata->>'role' = 'admin'
  `);
  
  return result.rows;
}

const admins = await getUsersWithMetadata();
admins.forEach(admin => {
  console.log(`Admin: ${admin.email}, Verified: ${admin.metadata.verified}`);
});

import { Pool, PoolConfig } from 'pg';

const config: PoolConfig = {
  // Базові параметри
  connectionString: process.env.DATABASE_URL,
  
  // === Розмір пулу ===
  min: 5,  // Мінімум підтримуваних з'єднань (завжди відкриті)
  max: 20, // Максимум одночасних з'єднань
  
  // === Таймаути ===
  connectionTimeoutMillis: 5000,  // Макс. час очікування вільного з'єднання
  idleTimeoutMillis: 30000,       // Закривати idle з'єднання через 30 сек
  
  // === Обробка помилок ===
  // Функція, що викликається при помилці на idle-з'єднанні
  on: {
    error: (err, client) => {
      console.error('Несподівана помилка на idle-з\'єднанні:', err.message);
      // Пул автоматично видалить проблемне з'єднання
    },
  },
  
  // === Розширені налаштування ===
  application_name: 'myapp_api', // Ім'я застосунку (видно у pg_stat_activity)
  statement_timeout: 10000,       // Скасувати запит, якщо виконується > 10 сек
  query_timeout: 5000,            // Таймаут для client.query()
};

const pool = new Pool(config);

import { Pool, PoolClient } from 'pg';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });

async function performComplexOperation() {
  const client: PoolClient = await pool.connect();
  
  try {
    // Тепер ми володіємо ексклюзивним з'єднанням
    await client.query('BEGIN'); // Початок транзакції
    
    const result1 = await client.query(
      'UPDATE accounts SET balance = balance - $1 WHERE id = $2',
      [100, 1]
    );
    
    const result2 = await client.query(
      'UPDATE accounts SET balance = balance + $1 WHERE id = $2',
      [100, 2]
    );
    
    await client.query('COMMIT'); // Фіксація змін
    console.log('Транзакція успішно завершена');
    
  } catch (error) {
    await client.query('ROLLBACK'); // Відкат при помилці
    console.error('Помилка транзакції, виконано rollback:', error);
    throw error;
    
  } finally {
    client.release(); // КРИТИЧНО: повертаємо з'єднання у пул!
  }
}

performComplexOperation();

import { Pool } from 'pg';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });

// Обробка сигналів завершення
process.on('SIGTERM', async () => {
  console.log('Отримано SIGTERM, закриваємо пул з\'єднань...');
  await pool.end(); // Чекає завершення всіх активних запитів
  console.log('Пул закрито, вихід.');
  process.exit(0);
});

process.on('SIGINT', async () => {
  console.log('Отримано SIGINT (Ctrl+C), закриваємо пул...');
  await pool.end();
  process.exit(0);
});

function logPoolMetrics(pool: Pool) {
  setInterval(() => {
    console.log({
      totalCount: pool.totalCount,     // Всього з'єднань у пулі
      idleCount: pool.idleCount,       // Вільних (idle)
      waitingCount: pool.waitingCount, // Очікують у черзі
    });
  }, 10000); // Кожні 10 секунд
}

logPoolMetrics(pool);

async function checkDatabaseHealth(pool: Pool): Promise<boolean> {
  try {
    const result = await pool.query('SELECT 1 AS alive');
    return result.rows[0].alive === 1;
  } catch (error) {
    console.error('Database health check failed:', error);
    return false;
  }
}

// Використання у Kubernetes liveness probe
app.get('/health', async (req, res) => {
  const isHealthy = await checkDatabaseHealth(pool);
  res.status(isHealthy ? 200 : 503).json({ database: isHealthy });
});

interface User {
  id: number;
  email: string;
  name: string;
  created_at: Date;
}

async function createUser(email: string, name: string): Promise<User> {
  const query = `
    INSERT INTO users (email, name, created_at)
    VALUES ($1, $2, NOW())
    RETURNING id, email, name, created_at
  `;
  
  const result = await pool.query<User>(query, [email, name]);
  return result.rows[0];
}

const user = await createUser('alice@example.com', 'Alice Smith');
console.log('Створено:', user);

async function createMultipleUsers(users: Array<{ email: string; name: string }>) {
  // Генеруємо плейсхолдери: ($1, $2), ($3, $4), ($5, $6)
  const values: any[] = [];
  const placeholders = users.map((user, index) => {
    values.push(user.email, user.name);
    const offset = index * 2;
    return `($${offset + 1}, $${offset + 2}, NOW())`;
  }).join(', ');
  
  const query = `
    INSERT INTO users (email, name, created_at)
    VALUES ${placeholders}
    RETURNING id, email, name
  `;
  
  const result = await pool.query(query, values);
  return result.rows;
}

const newUsers = await createMultipleUsers([
  { email: 'bob@example.com', name: 'Bob Johnson' },
  { email: 'charlie@example.com', name: 'Charlie Brown' },
]);

console.log('Створено користувачів:', newUsers.length);

async function getUsersByDomain(domain: string) {
  const query = `
    SELECT id, email, name, created_at
    FROM users
    WHERE email LIKE $1
    ORDER BY created_at DESC
  `;
  
  const result = await pool.query(query, [`%@${domain}`]);
  return result.rows;
}

const gmailUsers = await getUsersByDomain('gmail.com');
console.log('Користувачів з Gmail:', gmailUsers.length);

interface UserWithPosts {
  user_id: number;
  user_email: string;
  post_id: number | null;
  post_title: string | null;
  post_created_at: Date | null;
}

async function getUsersWithPosts(): Promise<UserWithPosts[]> {
  const query = `
    SELECT 
      u.id AS user_id,
      u.email AS user_email,
      p.id AS post_id,
      p.title AS post_title,
      p.created_at AS post_created_at
    FROM users u
    LEFT JOIN posts p ON p.user_id = u.id
    ORDER BY u.id, p.created_at DESC
  `;
  
  const result = await pool.query<UserWithPosts>(query);
  return result.rows;
}

async function updateUserEmail(userId: number, newEmail: string): Promise<void> {
  const query = `
    UPDATE users
    SET email = $1, updated_at = NOW()
    WHERE id = $2
  `;
  
  const result = await pool.query(query, [newEmail, userId]);
  
  if (result.rowCount === 0) {
    throw new Error(`Користувача з ID ${userId} не знайдено`);
  }
  
  console.log(`Оновлено email для користувача ${userId}`);
}

await updateUserEmail(42, 'newemail@example.com');

async function updateWithVersion(userId: number, newName: string, expectedVersion: number) {
  const query = `
    UPDATE users
    SET name = $1, version = version + 1, updated_at = NOW()
    WHERE id = $2 AND version = $3
    RETURNING version
  `;
  
  const result = await pool.query(query, [newName, userId, expectedVersion]);
  
  if (result.rowCount === 0) {
    throw new Error('Conflict: запис було змінено іншим процесом');
  }
  
  return result.rows[0].version;
}

async function deleteUser(userId: number): Promise<boolean> {
  const query = 'DELETE FROM users WHERE id = $1';
  const result = await pool.query(query, [userId]);
  
  return result.rowCount > 0; // true, якщо щось було видалено
}

const deleted = await deleteUser(99);
console.log(deleted ? 'Користувача видалено' : 'Користувача не знайдено');

async function transferMoney(fromUserId: number, toUserId: number, amount: number) {
  const client = await pool.connect();
  
  try {
    await client.query('BEGIN');
    
    // Зняти гроші з рахунку відправника
    const debitResult = await client.query(
      'UPDATE accounts SET balance = balance - $1 WHERE user_id = $2 RETURNING balance',
      [amount, fromUserId]
    );
    
    if (debitResult.rows[0].balance < 0) {
      throw new Error('Insufficient funds');
    }
    
    // Додати гроші на рахунок отримувача
    await client.query(
      'UPDATE accounts SET balance = balance + $1 WHERE user_id = $2',
      [amount, toUserId]
    );
    
    await client.query('COMMIT');
    console.log(`Переказано ${amount} від ${fromUserId} до ${toUserId}`);
    
  } catch (error) {
    await client.query('ROLLBACK');
    console.error('Помилка транзакції, виконано rollback:', error);
    throw error;
    
  } finally {
    client.release();
  }
}

await transferMoney(1, 2, 500);

import { DatabaseError } from 'pg';

async function createUserSafely(email: string, name: string) {
  try {
    const query = 'INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id';
    const result = await pool.query(query, [email, name]);
    return result.rows[0];
    
  } catch (error) {
    if (error instanceof DatabaseError) {
      // Обробка специфічних помилок PostgreSQL
      switch (error.code) {
        case '23505': // unique_violation
          throw new Error(`Email ${email} вже зареєстрований`);
          
        case '23502': // not_null_violation
          throw new Error(`Пропущено обов'язкове поле: ${error.column}`);
          
        case '23503': // foreign_key_violation
          throw new Error(`Порушення FK: ${error.detail}`);
          
        default:
          console.error('Database error:', error.code, error.message);
          throw error;
      }
    }
    
    // Мережеві або інші помилки
    console.error('Unexpected error:', error);
    throw error;
  }
}

import { Pool } from 'pg';
import * as http from 'http';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const server = http.createServer(async (req, res) => {
  try {
    const result = await pool.query('SELECT NOW()');
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ time: result.rows[0].now }));
  } catch (error) {
    res.writeHead(500);
    res.end('Database error');
  }
});

server.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

// Graceful shutdown
async function shutdown(signal: string) {
  console.log(`\nОтримано сигнал ${signal}, починаємо graceful shutdown...`);
  
  // 1. Зупиняємо прийом нових HTTP-запитів
  server.close(() => {
    console.log('HTTP-сервер зупинено');
  });
  
  // 2. Чекаємо завершення активних запитів до БД та закриваємо пул
  try {
    await pool.end();
    console.log('Пул з\'єднань закрито');
  } catch (error) {
    console.error('Помилка при закритті пулу:', error);
  }
  
  process.exit(0);
}

process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT'));

import { Pool, PoolClient } from 'pg';

interface User {
  id: number;
  email: string;
  name: string;
  created_at: Date;
  updated_at: Date;
}

interface CreateUserDto {
  email: string;
  name: string;
}

interface UpdateUserDto {
  name?: string;
  email?: string;
}

export class UserService {
  constructor(private pool: Pool) {}

  async create(dto: CreateUserDto): Promise<User> {
    const query = `
      INSERT INTO users (email, name, created_at, updated_at)
      VALUES ($1, $2, NOW(), NOW())
      RETURNING id, email, name, created_at, updated_at
    `;
    
    const result = await this.pool.query<User>(query, [dto.email, dto.name]);
    return result.rows[0];
  }

  async findById(id: number): Promise<User | null> {
    const query = 'SELECT * FROM users WHERE id = $1';
    const result = await this.pool.query<User>(query, [id]);
    return result.rows[0] || null;
  }

  async findByEmail(email: string): Promise<User | null> {
    const query = 'SELECT * FROM users WHERE email = $1';
    const result = await this.pool.query<User>(query, [email]);
    return result.rows[0] || null;
  }

  async findAll(limit = 100, offset = 0): Promise<User[]> {
    const query = `
      SELECT * FROM users
      ORDER BY created_at DESC
      LIMIT $1 OFFSET $2
    `;
    const result = await this.pool.query<User>(query, [limit, offset]);
    return result.rows;
  }

  async update(id: number, dto: UpdateUserDto): Promise<User | null> {
    const fields: string[] = [];
    const values: any[] = [];
    let paramIndex = 1;

    if (dto.name !== undefined) {
      fields.push(`name = $${paramIndex++}`);
      values.push(dto.name);
    }

    if (dto.email !== undefined) {
      fields.push(`email = $${paramIndex++}`);
      values.push(dto.email);
    }

    if (fields.length === 0) {
      return this.findById(id); // Нічого не змінено
    }

    fields.push(`updated_at = NOW()`);
    values.push(id);

    const query = `
      UPDATE users
      SET ${fields.join(', ')}
      WHERE id = $${paramIndex}
      RETURNING id, email, name, created_at, updated_at
    `;

    const result = await this.pool.query<User>(query, values);
    return result.rows[0] || null;
  }

  async delete(id: number): Promise<boolean> {
    const query = 'DELETE FROM users WHERE id = $1';
    const result = await this.pool.query(query, [id]);
    return result.rowCount > 0;
  }

  // Приклад транзакції: переміщення користувача в архів
  async archive(id: number): Promise<void> {
    const client: PoolClient = await this.pool.connect();

    try {
      await client.query('BEGIN');

      // Копіюємо користувача в архівну таблицю
      await client.query(`
        INSERT INTO users_archive (id, email, name, created_at, archived_at)
        SELECT id, email, name, created_at, NOW()
        FROM users
        WHERE id = $1
      `, [id]);

      // Видаляємо з основної таблиці
      await client.query('DELETE FROM users WHERE id = $1', [id]);

      await client.query('COMMIT');
      console.log(`Користувача ${id} переміщено в архів`);

    } catch (error) {
      await client.query('ROLLBACK');
      console.error('Помилка архівування:', error);
      throw error;

    } finally {
      client.release();
    }
  }
}

// Використання:
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const userService = new UserService(pool);

(async () => {
  const user = await userService.create({
    email: 'test@example.com',
    name: 'Test User',
  });

  console.log('Створено:', user);

  const found = await userService.findById(user.id);
  console.log('Знайдено:', found);

  await userService.update(user.id, { name: 'Updated Name' });
  console.log('Оновлено');

  await userService.archive(user.id);
  console.log('Заархівовано');
})();

import { Module, Global } from '@nestjs/common';
import { Pool } from 'pg';

export const PG_CONNECTION = 'PG_CONNECTION';

@Global()
@Module({
  providers: [
    {
      provide: PG_CONNECTION,
      useFactory: () => {
        const pool = new Pool({
          connectionString: process.env.DATABASE_URL,
          max: 20,
          idleTimeoutMillis: 30000,
        });

        pool.on('error', (err) => {
          console.error('Unexpected error on idle client', err);
        });

        return pool;
      },
    },
  ],
  exports: [PG_CONNECTION],
})
export class DatabaseModule {}

import { Injectable, Inject } from '@nestjs/common';
import { Pool } from 'pg';
import { PG_CONNECTION } from './database.module';

@Injectable()
export class UsersService {
  constructor(@Inject(PG_CONNECTION) private pool: Pool) {}

  async findAll() {
    const result = await this.pool.query('SELECT * FROM users');
    return result.rows;
  }

  async create(email: string, name: string) {
    const query = 'INSERT INTO users (email, name) VALUES ($1, $2) RETURNING *';
    const result = await this.pool.query(query, [email, name]);
    return result.rows[0];
  }
}

import { Controller, Get, Post, Body } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}

  @Get()
  async findAll() {
    return this.usersService.findAll();
  }

  @Post()
  async create(@Body() body: { email: string; name: string }) {
    return this.usersService.create(body.email, body.name);
  }
}