import fs from 'node:fs/promises';

// ❌ ПРОБЛЕМА: весь файл завантажується у пам'ять
async function processLargeFile() {
  // Якщо файл має розмір 2 ГБ, Node.js спробує виділити 2 ГБ RAM
  const data = await fs.readFile('video.mp4'); // Buffer(2 GB)
  
  // Обробка даних
  const processed = transformData(data);
  
  // Запис результату (ще +2 ГБ у пам'яті)
  await fs.writeFile('output.mp4', processed);
}

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import http from 'node:http';
import zlib from 'node:zlib';
import crypto from 'node:crypto';

// 1. Файлова система
const readStream = fs.createReadStream('input.txt');   // Readable
const writeStream = fs.createWriteStream('output.txt'); // Writable

// 2. HTTP (request та response — це streams)
http.createServer((req, res) => {
  req.pipe(res); // Readable (request) → Writable (response)
});

// 3. Стиснення та шифрування
const gzip = zlib.createGzip();           // Transform
const cipher = crypto.createCipher('aes-256-cbc', 'password'); // Transform

// 4. Process stdio
process.stdin.pipe(process.stdout);  // stdin → stdout (echo)

// 5. Child processes
import { spawn } from 'node:child_process';
const ls = spawn('ls', ['-la']);
ls.stdout.pipe(process.stdout); // Вивід дочірнього процесу → stdout

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

const readStream = fs.createReadStream('data.txt');

// Підписка на події (event-driven programming)
readStream.on('data', (chunk: Buffer) => {
  console.log('Отримано chunk розміром:', chunk.length);
});

readStream.on('end', (): void => {
  console.log('Читання завершено');
});

readStream.on('error', (error: Error) => {
  console.error('Помилка читання:', error);
});

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

// Створення потоку для читання файлу
const readStream = fs.createReadStream('large-file.txt', {
  encoding: 'utf8',      // Автоматична конвертація Buffer → String
  highWaterMark: 64 * 1024,  // Розмір буфера (64 КБ за замовчуванням)
  start: 0,              // Початкова позиція у файлі (байт)
  end: undefined,        // Кінцева позиція (undefined = до кінця файлу)
  autoClose: true        // Автоматичне закриття файлового дескриптора
});

console.log('Stream створено, але читання ще не почалося');

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

const stream = fs.createReadStream('data.txt', { encoding: 'utf8' });

// Підписка на подію 'data' автоматично переводить потік у flowing mode
stream.on('data', (chunk: Buffer) => {
  console.log('Отримано chunk:', chunk);
  // Дані надходять автоматично, доки не закінчаться або не буде викликано pause()
});

stream.on('end', (): void => {
  console.log('Читання завершено');
});

stream.on('error', (error: Error) => {
  console.error('Помилка:', error);
});

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

const stream = fs.createReadStream('data.txt');

// За замовчуванням потік у paused mode
stream.on('readable', () => {
  let chunk;
  
  // Явне читання даних з внутрішнього буфера
  while ((chunk = stream.read()) !== null) {
    console.log('Прочитано chunk розміром:', chunk.length);
    
    // Можна обробляти chunk синхронно
    processChunk(chunk);
  }
});

stream.on('end', (): void => {
  console.log('Читання завершено');
});

function processChunk(chunk) {
  // Синхронна обробка
  console.log('Обробка:', chunk.toString('utf8').slice(0, 50));
}

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

function analyzeFile(filePath) {
  const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
  
  let totalBytes = 0;
  let totalLines = 0;
  let totalWords = 0;
  let chunkCount = 0;
  
  stream.on('data', (chunk: Buffer) => {
    chunkCount++;
    totalBytes += Buffer.byteLength(chunk, 'utf8');
    
    // Підрахунок рядків
    totalLines += (chunk.match(/\n/g) || []).length;
    
    // Підрахунок слів (приблизно)
    totalWords += chunk.split(/\s+/).filter(Boolean).length;
  });
  
  stream.on('end', (): void => {
    console.log('Аналіз завершено:');
    console.log(`  Байти: ${totalBytes.toLocaleString()}`);
    console.log(`  Рядки: ${totalLines.toLocaleString()}`);
    console.log(`  Слова: ${totalWords.toLocaleString()}`);
    console.log(`  Chunks: ${chunkCount}`);
    console.log(`  Середній розмір chunk: ${Math.round(totalBytes / chunkCount)} байт`);
  });
  
  stream.on('error', (error: Error) => {
    console.error('Помилка читання файлу:', error.message);
  });
}

// Використання
analyzeFile('large-document.txt');

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

const stream = fs.createReadStream('large-file.txt', { encoding: 'utf8' });

let processedChunks = 0;

stream.on('data', (chunk: Buffer) => {
  processedChunks++;
  console.log(`Обробка chunk #${processedChunks}`);
  
  // Симуляція повільної обробки
  processSlowly(chunk);
  
  // Після кожних 5 chunks — пауза на 2 секунди
  if (processedChunks % 5 === 0) {
    console.log('Призупинення потоку на 2 секунди...');
    stream.pause();
    
    setTimeout(() => {
      console.log('Відновлення потоку');
      stream.resume();
    }, 2000);
  }
});

stream.on('end', (): void => {
  console.log(`Оброблено ${processedChunks} chunks`);
});

function processSlowly(chunk) {
  // Симуляція CPU-інтенсивної операції
  const lines = chunk.split('\n');
  for (const line of lines) {
    if (line.includes('ERROR')) {
      console.log('Знайдено помилку:', line.slice(0, 50));
    }
  }
}

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

// Читання лише перших 1024 байтів файлу
function readFileHeader(filePath) {
  const stream = fs.createReadStream(filePath, {
    start: 0,
    end: 1023  // Прочитати байти 0-1023 (включно)
  });
  
  let header = '';
  
  stream.on('data', (chunk: Buffer) => {
    header += chunk.toString('utf8');
  });
  
  stream.on('end', (): void => {
    console.log('Заголовок файлу (перші 1024 байти):');
    console.log(header);
  });
}

// HTTP Range Request (resumable downloads)
function serveFileRange(filePath, rangeHeader, response) {
  const stat = fs.statSync(filePath);
  const fileSize = stat.size;
  
  // Парсинг заголовка Range: bytes=0-1023
  const range = /bytes=(\d+)-(\d*)/.exec(rangeHeader);
  if (!range) {
    response.writeHead(416); // Range Not Satisfiable
    response.end();
    return;
  }
  
  const start = parseInt(range[1], 10);
  const end = range[2] ? parseInt(range[2], 10) : fileSize - 1;
  const chunkSize = end - start + 1;
  
  // HTTP 206 Partial Content
  response.writeHead(206, {
    'Content-Range': `bytes ${start}-${end}/${fileSize}`,
    'Accept-Ranges': 'bytes',
    'Content-Length': chunkSize,
    'Content-Type': 'application/octet-stream'
  });
  
  // Потоковий запис лише вказаного діапазону
  const stream = fs.createReadStream(filePath, { start, end });
  stream.pipe(response);
}

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

// Створення потоку для запису
const writeStream = fs.createWriteStream('output.txt', {
  encoding: 'utf8',
  flags: 'w',            // 'w' — перезаписати, 'a' — додати до кінця
  mode: 0o666,           // Права доступу (rw-rw-rw-)
  highWaterMark: 16 * 1024,  // Розмір буфера (16 КБ за замовчуванням)
  autoClose: true
});

console.log('Writable Stream створено');

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

const writeStream = fs.createWriteStream('log.txt', { flags: 'a' });

// Запис кількох рядків
writeStream.write('Перший рядок\n');
writeStream.write('Другий рядок\n');
writeStream.write('Третій рядок\n');

// Завершення запису
writeStream.end('Останній рядок\n', () => {
  console.log('Всі дані записано на диск');
});

writeStream.on('error', (error: Error) => {
  console.error('Помилка запису:', error);
});

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

const writeStream = fs.createWriteStream('large-output.txt');

function writeMillionLines() {
  let lineNumber = 0;
  const totalLines = 1_000_000;
  
  function writeNext() {
    let canContinue = true;
    
    // Пишемо, доки write() повертає true
    while (lineNumber < totalLines && canContinue) {
      const line = `Рядок номер ${lineNumber}\n`;
      lineNumber++;
      
      if (lineNumber === totalLines) {
        // Останній рядок — завершуємо потік
        writeStream.end(line, () => {
          console.log(`Записано ${totalLines} рядків`);
        });
      } else {
        // Продовжуємо запис
        canContinue = writeStream.write(line);
      }
    }
    
    // Якщо write() повернув false, чекаємо 'drain'
    if (lineNumber < totalLines) {
      console.log(`Backpressure на рядку ${lineNumber}, очікування drain...`);
      writeStream.once('drain', writeNext);
    }
  }
  
  writeNext();
}

writeMillionLines();

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

function generateLargeCSV(filename, rowCount) {
  const writeStream = fs.createWriteStream(filename, { encoding: 'utf8' });
  
  // Заголовки CSV
  writeStream.write('id,name,email,age,created_at\n');
  
  let currentRow = 0;
  let bytesWritten = 0;
  const startTime = Date.now();
  
  function writeRows() {
    let canContinue = true;
    
    while (currentRow < rowCount && canContinue) {
      currentRow++;
      
      const row = [
        currentRow,
        `User${currentRow}`,
        `user${currentRow}@example.com`,
        Math.floor(Math.random() * 60) + 18,
        new Date().toISOString()
      ].join(',') + '\n';
      
      bytesWritten += Buffer.byteLength(row, 'utf8');
      
      if (currentRow === rowCount) {
        // Останній рядок
        writeStream.end(row);
      } else {
        canContinue = writeStream.write(row);
      }
      
      // Прогрес кожні 100000 рядків
      if (currentRow % 100000 === 0) {
        const elapsed = (Date.now() - startTime) / 1000;
        const speed = Math.round(currentRow / elapsed);
        console.log(`Прогрес: ${currentRow}/${rowCount} (${speed} рядків/сек)`);
      }
    }
    
    if (currentRow < rowCount) {
      // Backpressure — чекаємо drain
      writeStream.once('drain', writeRows);
    }
  }
  
  writeStream.on('finish', (): void => {
    const totalTime = (Date.now() - startTime) / 1000;
    const sizeMB = (bytesWritten / 1024 / 1024).toFixed(2);
    const speed = Math.round(rowCount / totalTime);
    
    console.log('\n✅ Генерацію завершено:');
    console.log(`   Файл: ${filename}`);
    console.log(`   Рядків: ${rowCount.toLocaleString()}`);
    console.log(`   Розмір: ${sizeMB} МБ`);
    console.log(`   Час: ${totalTime.toFixed(2)} сек`);
    console.log(`   Швидкість: ${speed.toLocaleString()} рядків/сек`);
  });
  
  writeStream.on('error', (error: Error) => {
    console.error('Помилка запису:', error.message);
  });
  
  // Почати запис
  writeRows();
}

// Згенерувати CSV з 10 мільйонами рядків
generateLargeCSV('users.csv', 10_000_000);

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

function splitLogsByLevel(inputFile) {
  const readStream = fs.createReadStream(inputFile, { encoding: 'utf8' });
  
  // Три окремі потоки для запису
  const streams = {
    info: fs.createWriteStream('info.log'),
    warn: fs.createWriteStream('warn.log'),
    error: fs.createWriteStream('error.log')
  };
  
  let buffer = '';
  
  readStream.on('data', (chunk: Buffer) => {
    buffer += chunk;
    
    // Обробка повних рядків
    let lines = buffer.split('\n');
    buffer = lines.pop(); // Зберегти неповний останній рядок
    
    for (const line of lines) {
      if (line.includes('[INFO]')) {
        streams.info.write(line + '\n');
      } else if (line.includes('[WARN]')) {
        streams.warn.write(line + '\n');
      } else if (line.includes('[ERROR]')) {
        streams.error.write(line + '\n');
      }
    }
  });
  
  readStream.on('end', (): void => {
    // Записати залишок буфера
    if (buffer) {
      if (buffer.includes('[INFO]')) streams.info.write(buffer + '\n');
      else if (buffer.includes('[WARN]')) streams.warn.write(buffer + '\n');
      else if (buffer.includes('[ERROR]')) streams.error.write(buffer + '\n');
    }
    
    // Закрити всі потоки
    streams.info.end();
    streams.warn.end();
    streams.error.end();
    
    console.log('Логи розділено за рівнями');
  });
  
  readStream.on('error', (error: Error) => {
    console.error('Помилка читання:', error);
  });
}

splitLogsByLevel('application.log');

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

// Ручний підхід (багато коду)
const readStream = fs.createReadStream('input.txt');
const writeStream = fs.createWriteStream('output.txt');

readStream.on('data', (chunk: Buffer) => {
  const canContinue = writeStream.write(chunk);
  if (!canContinue) {
    readStream.pause(); // Backpressure
  }
});

writeStream.on('drain', (): void => {
  readStream.resume();
});

readStream.on('end', (): void => {
  writeStream.end();
});

// ✅ З pipe() — один рядок
fs.createReadStream('input.txt')
  .pipe(fs.createWriteStream('output.txt'));

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

function copyFile(source, destination) {
  const readStream = fs.createReadStream(source);
  const writeStream = fs.createWriteStream(destination);
  
  // Pipe автоматично обробляє backpressure
  readStream.pipe(writeStream);
  
  // Обробка завершення
  writeStream.on('finish', (): void => {
    console.log(`Файл скопійовано: ${source} → ${destination}`);
  });
  
  // Обробка помилок
  readStream.on('error', (error: Error) => {
    console.error('Помилка читання:', error.message);
  });
  
  writeStream.on('error', (error: Error) => {
    console.error('Помилка запису:', error.message);
    readStream.destroy(); // Зупинити читання при помилці запису
  });
}

copyFile('large-video.mp4', 'backup-video.mp4');

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import zlib from 'node:zlib';

function compressFile(inputFile, outputFile) {
  const readStream = fs.createReadStream(inputFile);
  const gzipStream = zlib.createGzip({ level: 9 }); // Максимальне стиснення
  const writeStream = fs.createWriteStream(outputFile);
  
  // Ланцюжок: Читання → Стиснення → Запис
  readStream
    .pipe(gzipStream)
    .pipe(writeStream);
  
  // Відстеження прогресу
  let inputBytes = 0;
  let outputBytes = 0;
  
  readStream.on('data', (chunk: Buffer) => {
    inputBytes += chunk.length;
  });
  
  gzipStream.on('data', (chunk: Buffer) => {
    outputBytes += chunk.length;
  });
  
  writeStream.on('finish', (): void => {
    const ratio = ((1 - outputBytes / inputBytes) * 100).toFixed(2);
    console.log(`Стиснення завершено:`);
    console.log(`  Вхід: ${(inputBytes / 1024 / 1024).toFixed(2)} МБ`);
    console.log(`  Вихід: ${(outputBytes / 1024 / 1024).toFixed(2)} МБ`);
    console.log(`  Компресія: ${ratio}%`);
  });
  
  // Обробка помилок на кожному етапі
  readStream.on('error', (error: Error) => {
    console.error('Помилка читання:', error.message);
  });
  
  gzipStream.on('error', (error: Error) => {
    console.error('Помилка стиснення:', error.message);
  });
  
  writeStream.on('error', (error: Error) => {
    console.error('Помилка запису:', error.message);
  });
}

compressFile('document.txt', 'document.txt.gz');

import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import zlib from 'node:zlib';

function decompressFile(gzipFile, outputFile) {
  fs.createReadStream(gzipFile)
    .pipe(zlib.createGunzip())
    .pipe(fs.createWriteStream(outputFile))
    .on('finish', (): void => {
      console.log(`Розпаковано: ${gzipFile} → ${outputFile}`);
    });
}

decompressFile('document.txt.gz', 'document-restored.txt');

import { pipeline } from 'node:stream/promises';
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import zlib from 'node:zlib';

async function compressFileModern(inputFile, outputFile) {
  try {
    await pipeline(
      fs.createReadStream(inputFile),
      zlib.createGzip({ level: 9 }),
      fs.createWriteStream(outputFile)
    );
    
    console.log(`✅ Стиснення успішне: ${inputFile} → ${outputFile}`);
  } catch (error) {
    console.error('❌ Помилка під час стиснення:', error.message);
    
    // Автоматичне очищення: всі потоки закриваються при помилці
    // Видалення частково записаного файлу
    try {
      await fs.promises.unlink(outputFile);
    } catch {
      // Файл не існує або вже видалений
    }
  }
}

// Використання з async/await
await compressFileModern('large-file.txt', 'large-file.txt.gz');

import { pipeline } from 'node:stream/promises';
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import crypto from 'node:crypto';
import zlib from 'node:zlib';

async function encryptAndCompress(inputFile, outputFile, password) {
  // Генерація ключа шифрування з пароля
  const key = crypto.scryptSync(password, 'salt', 32);
  const iv = crypto.randomBytes(16);
  
  // Збереження IV на початку файлу (потрібен для розшифрування)
  const outputStream = fs.createWriteStream(outputFile);
  outputStream.write(iv);
  
  try {
    await pipeline(
      fs.createReadStream(inputFile),
      zlib.createGzip({ level: 6 }),                    // 1. Стиснення
      crypto.createCipheriv('aes-256-cbc', key, iv),    // 2. Шифрування
      outputStream                                       // 3. Запис
    );
    
    console.log('✅ Файл зашифровано та стиснено');
  } catch (error) {
    console.error('❌ Помилка:', error.message);
    
    // Видалення некоректного файлу
    try {
      await fs.promises.unlink(outputFile);
    } catch {}
  }
}

async function decryptAndDecompress(inputFile, outputFile, password) {
  const key = crypto.scryptSync(password, 'salt', 32);
  
  // Читання IV з початку файлу
  const fileHandle = await fs.promises.open(inputFile, 'r');
  const iv = Buffer.alloc(16);
  await fileHandle.read(iv, 0, 16, 0);
  
  // Створення потоку, який пропускає перші 16 байтів
  const readStream = fs.createReadStream(inputFile, { start: 16 });
  
  try {
    await pipeline(
      readStream,
      crypto.createDecipheriv('aes-256-cbc', key, iv),  // 1. Розшифрування
      zlib.createGunzip(),                               // 2. Розпаковка
      fs.createWriteStream(outputFile)                   // 3. Запис
    );
    
    console.log('✅ Файл розшифровано та розпаковано');
  } catch (error) {
    console.error('❌ Помилка:', error.message);
  } finally {
    await fileHandle.close();
  }
}

// Використання
await encryptAndCompress('secret-document.pdf', 'encrypted.bin', 'my-password-123');
await decryptAndDecompress('encrypted.bin', 'decrypted-document.pdf', 'my-password-123');

import http from 'node:http';
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import path from 'node:path';

const server = http.createServer((req, res) => {
  const filePath = path.join(process.cwd(), 'public', req.url);
  
  // Перевірка існування файлу
  fs.stat(filePath, (err, stats) => {
    if (err || !stats.isFile()) {
      res.writeHead(404, { 'Content-Type': 'text/plain' });
      res.end('File not found');
      return;
    }
    
    // Встановлення заголовків
    res.writeHead(200, {
      'Content-Type': 'application/octet-stream',
      'Content-Length': stats.size,
      'Content-Disposition': `attachment; filename="${path.basename(filePath)}"`
    });
    
    // Потокове передавання файлу клієнту
    const readStream = fs.createReadStream(filePath);
    
    // res (ServerResponse) є Writable Stream
    readStream.pipe(res);
    
    // Обробка помилок
    readStream.on('error', (error: Error) => {
      console.error('Помилка читання файлу:', error);
      res.destroy(); // Розірвати з'єднання
    });
    
    // Клієнт розірвав з'єднання (наприклад, скасував завантаження)
    res.on('close', (): void => {
      readStream.destroy();
      console.log('Клієнт розірвав з\'єднання');
    });
  });
});

server.listen(3000, () => {
  console.log('Файловий сервер запущено на http://127.0.0.1:3000');
});

import { Transform } from 'node:stream';
import type { TransformCallback } from 'node:stream';

// Приклад: перетворення тексту у верхній регістр
class UpperCaseTransform extends Transform {
  _transform(chunk: Buffer | string, encoding: BufferEncoding, callback: TransformCallback): void {
    // chunk — вхідні дані (Buffer або string)
    // encoding — кодування (якщо chunk є рядком)
    // callback(error, transformedChunk) — виклик після трансформації
    
    const upperCased = chunk.toString().toUpperCase();
    this.push(upperCased); // Відправити трансформовані дані далі
    callback(); // Сигнал, що chunk оброблено
  }
}

// Використання
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

fs.createReadStream('input.txt', { encoding: 'utf8' })
  .pipe(new UpperCaseTransform())
  .pipe(fs.createWriteStream('output.txt'))
  .on('finish', (): void => {
    console.log('Файл перетворено у верхній регістр');
  });

import { Transform } from 'node:stream';
import type { TransformCallback } from 'node:stream';

class ReplaceTransform extends Transform {
  constructor(searchValue, replaceValue, options) {
    super(options);
    this.searchValue = searchValue;
    this.replaceValue = replaceValue;
    this.buffer = '';
  }
  
  _transform(chunk, encoding, callback) {
    // Накопичуємо дані у буфері для коректної обробки меж chunks
    this.buffer += chunk.toString();
    
    // Обробляємо повні рядки
    const lines = this.buffer.split('\n');
    this.buffer = lines.pop(); // Зберегти неповний останній рядок
    
    for (const line of lines) {
      const replaced = line.replace(
        new RegExp(this.searchValue, 'g'),
        this.replaceValue
      );
      this.push(replaced + '\n');
    }
    
    callback();
  }
  
  _flush(callback) {
    // Відправити залишок буфера
    if (this.buffer) {
      const replaced = this.buffer.replace(
        new RegExp(this.searchValue, 'g'),
        this.replaceValue
      );
      this.push(replaced);
    }
    callback();
  }
}

// Використання: заміна всіх 'error' на 'warning' у лог-файлі
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

fs.createReadStream('app.log', { encoding: 'utf8' })
  .pipe(new ReplaceTransform('error', 'warning'))
  .pipe(fs.createWriteStream('app-sanitized.log'));

import { Transform } from 'node:stream';
import type { TransformCallback } from 'node:stream';

class StatisticsTransform extends Transform {
  constructor(options) {
    super(options);
    this.lines = 0;
    this.words = 0;
    this.bytes = 0;
  }
  
  _transform(chunk, encoding, callback) {
    const text = chunk.toString();
    this.bytes += Buffer.byteLength(text);
    this.lines += (text.match(/\n/g) || []).length;
    this.words += text.split(/\s+/).filter(Boolean).length;
    
    // Пропускаємо дані далі без змін
    this.push(chunk);
    callback();
  }
  
  _flush(callback) {
    // Виведення статистики після обробки всіх даних
    console.log('\nСтатистика файлу:');
    console.log(`  Байти: ${this.bytes.toLocaleString()}`);
    console.log(`  Рядки: ${this.lines.toLocaleString()}`);
    console.log(`  Слова: ${this.words.toLocaleString()}`);
    callback();
  }
}

// Використання: копіювання файлу з підрахунком статистики
fs.createReadStream('large-document.txt', { encoding: 'utf8' })
  .pipe(new StatisticsTransform())
  .pipe(fs.createWriteStream('copy.txt'))
  .on('finish', (): void => {
    console.log('Копіювання завершено');
  });

import { Transform } from 'node:stream';
import type { TransformCallback } from 'node:stream';

class GrepTransform extends Transform {
  constructor(pattern, options) {
    super({ ...options, encoding: 'utf8' });
    this.pattern = new RegExp(pattern);
    this.buffer = '';
  }
  
  _transform(chunk, encoding, callback) {
    this.buffer += chunk;
    const lines = this.buffer.split('\n');
    this.buffer = lines.pop();
    
    for (const line of lines) {
      if (this.pattern.test(line)) {
        this.push(line + '\n'); // Пропускаємо лише рядки, що співпадають
      }
    }
    
    callback();
  }
  
  _flush(callback) {
    if (this.buffer && this.pattern.test(this.buffer)) {
      this.push(this.buffer + '\n');
    }
    callback();
  }
}

// Використання: фільтрація лише рядків з 'ERROR'
fs.createReadStream('app.log', { encoding: 'utf8' })
  .pipe(new GrepTransform('ERROR'))
  .pipe(process.stdout); // Виведення у консоль

import { Transform } from 'node:stream';
import type { TransformCallback } from 'node:stream';
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import { parse } from 'csv-parse';

// Transform Stream для парсингу CSV у об'єкти
function createCsvParser() {
  return parse({
    columns: true,      // Перший рядок — заголовки
    skip_empty_lines: true
  });
}

// Transform Stream для валідації користувачів
class UserValidator extends Transform {
  constructor(options) {
    super({ ...options, objectMode: true }); // Увімкнути Object Mode
  }
  
  _transform(user, encoding, callback) {
    // user — це JavaScript-об'єкт, а не Buffer
    const errors = [];
    
    if (!user.email || !user.email.includes('@')) {
      errors.push('Invalid email');
    }
    
    if (!user.age || isNaN(user.age) || user.age < 0) {
      errors.push('Invalid age');
    }
    
    if (errors.length === 0) {
      // Пропустити валідний об'єкт
      this.push({
        ...user,
        age: parseInt(user.age, 10),
        validated: true
      });
    } else {
      // Відхилити невалідний (або можна push з полем errors)
      console.warn(`Відхилено користувача: ${user.email || 'unknown'} (${errors.join(', ')})`);
    }
    
    callback();
  }
}

// Transform Stream для конвертації у JSON
class JsonStringifier extends Transform {
  constructor(options) {
    super({ ...options, objectMode: true, writableObjectMode: true, readableObjectMode: false });
    this.first = true;
  }
  
  _transform(obj, encoding, callback) {
    const json = JSON.stringify(obj);
    if (this.first) {
      this.push('[' + json);
      this.first = false;
    } else {
      this.push(',' + json);
    }
    callback();
  }
  
  _flush(callback) {
    this.push(']');
    callback();
  }
}

// Конвеєр: CSV → Об'єкти → Валідація → JSON → Файл
fs.createReadStream('users.csv', { encoding: 'utf8' })
  .pipe(createCsvParser())           // CSV → Об'єкти
  .pipe(new UserValidator())         // Валідація
  .pipe(new JsonStringifier())       // Об'єкти → JSON string
  .pipe(fs.createWriteStream('valid-users.json'))
  .on('finish', (): void => {
    console.log('Обробку CSV завершено');
  });

import zlib from 'node:zlib';
import crypto from 'node:crypto';

// 1. Стиснення та розпаковка (zlib)
const gzip = zlib.createGzip();
const gunzip = zlib.createGunzip();
const deflate = zlib.createDeflate();
const inflate = zlib.createInflate();
const brotli = zlib.createBrotliCompress();

// 2. Шифрування та розшифрування (crypto)
const cipher = crypto.createCipher('aes-256-cbc', 'password');
const decipher = crypto.createDecipher('aes-256-cbc', 'password');

// 3. Хешування (crypto)
const hash = crypto.createHash('sha256');
hash.on('readable', () => {
  const data = hash.read();
  if (data) {
    console.log('SHA256:', data.toString('hex'));
  }
});

fs.createReadStream('file.txt').pipe(hash);

// 4. HMAC (crypto)
const hmac = crypto.createHmac('sha256', 'secret-key');
fs.createReadStream('data.bin').pipe(hmac).pipe(process.stdout);

import http from 'node:http';
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';
import path from 'node:path';
import { pipeline } from 'node:stream/promises';

const UPLOAD_DIR = './uploads';

// Створення директорії для завантажень
if (!fs.existsSync(UPLOAD_DIR)) {
  fs.mkdirSync(UPLOAD_DIR, { recursive: true });
}

const server = http.createServer(async (req, res) => {
  if (req.method === 'POST' && req.url === '/upload') {
    const filename = req.headers['x-filename'] || `upload-${Date.now()}.bin`;
    const filepath = path.join(UPLOAD_DIR, filename);
    
    // Обмеження розміру файлу
    const maxSize = 100 * 1024 * 1024; // 100 МБ
    let uploadedBytes = 0;
    
    const writeStream = fs.createWriteStream(filepath);
    
    // Моніторинг прогресу
    req.on('data', (chunk: Buffer) => {
      uploadedBytes += chunk.length;
      
      if (uploadedBytes > maxSize) {
        req.destroy();
        writeStream.destroy();
        
        // Видалення частково завантаженого файлу
        fs.unlink(filepath, () => {});
        
        res.writeHead(413, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'File too large' }));
      }
    });
    
    try {
      await pipeline(req, writeStream);
      
      res.writeHead(201, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        message: 'File uploaded successfully',
        filename,
        size: uploadedBytes
      }));
    } catch (error) {
      console.error('Upload error:', error);
      
      // Очищення при помилці
      try {
        await fs.promises.unlink(filepath);
      } catch {}
      
      if (!res.headersSent) {
        res.writeHead(500, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'Upload failed' }));
      }
    }
  } else {
    res.writeHead(404);
    res.end('Not found');
  }
});

server.listen(3000, () => {
  console.log('Upload server running on http://127.0.0.1:3000');
  console.log('Upload files: curl -X POST -H "X-Filename: test.txt" --data-binary @file.txt http://127.0.0.1:3000/upload');
});

import { Transform } from 'node:stream';
import type { TransformCallback } from 'node:stream';
import fs from 'node:fs';
import type { ReadStream, WriteStream } from 'node:fs';

// Transform Stream для парсингу JSON-масиву по одному елементу
class JsonArrayParser extends Transform {
  constructor(options) {
    super({ ...options, objectMode: true });
    this.buffer = '';
    this.depth = 0;
    this.inArray = false;
  }
  
  _transform(chunk, encoding, callback) {
    this.buffer += chunk.toString();
    
    let startPos = 0;
    
    for (let i = 0; i < this.buffer.length; i++) {
      const char = this.buffer[i];
      
      if (char === '[') {
        this.depth++;
        if (this.depth === 1) {
          this.inArray = true;
          startPos = i + 1;
        }
      } else if (char === ']') {
        this.depth--;
        if (this.depth === 0 && this.inArray) {
          // Кінець масиву
          const lastObject = this.buffer.slice(startPos, i).trim();
          if (lastObject && lastObject !== ',') {
            try {
              const obj = JSON.parse(lastObject.replace(/,$/, ''));
              this.push(obj);
            } catch (error) {
              console.error('Parse error:', error);
            }
          }
          this.buffer = this.buffer.slice(i + 1);
          return callback();
        }
      } else if (char === ',' && this.depth === 1) {
        // Знайдено об'єкт
        const objectStr = this.buffer.slice(startPos, i).trim();
        if (objectStr) {
          try {
            const obj = JSON.parse(objectStr);
            this.push(obj);
          } catch (error) {
            console.error('Parse error:', error);
          }
        }
        startPos = i + 1;
      }
    }
    
    // Зберегти необроблений залишок
    if (startPos > 0) {
      this.buffer = this.buffer.slice(startPos);
    }
    
    callback();
  }
}

// Використання: обробка великого JSON-масиву
fs.createReadStream('large-array.json', { encoding: 'utf8' })
  .pipe(new JsonArrayParser())
  .on('data', (object) => {
    // Обробка кожного об'єкта окремо
    console.log('Отримано об\'єкт:', object.id);
  })
  .on('end', (): void => {
    console.log('Парсинг JSON завершено');
  });