// CommonJS (Node.js традиційний синтаксис)
const http = require('http');

// ES Modules (сучасний стандарт)
import http from 'node:http';
import type { Server, IncomingMessage, ServerResponse } from 'node:http';

// Імпорт окремих функцій з типами
import { createServer, request } from 'node:http';

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

// Створення сервера з обробником запитів
const server = http.createServer((request: IncomingMessage, response: ServerResponse): void => {
  // Встановлення коду статусу та заголовків
  response.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  
  // Відправка тіла відповіді
  response.end('Привіт, світ! Це Node.js HTTP-сервер.');
});

// Прив'язка сервера до порту 3000
const PORT = 3000;
const HOST = '127.0.0.1';

server.listen(PORT, HOST, (): void => {
  console.log(`Сервер запущено на http://${HOST}:${PORT}/`);
});

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
  res.end('Server is running');
});

// Варіанти прив'язки до порту
server.listen(3000); // Тільки порт (хост за замовчуванням)

server.listen(3000, '127.0.0.1'); // Локальний доступ

server.listen(3000, '0.0.0.0', (): void => {
  console.log('Сервер доступний з будь-якого мережевого інтерфейсу');
});

// Використання змінних оточення
const PORT = process.env.PORT || 3000;
const HOST = process.env.HOST || '0.0.0.0';

server.listen(PORT, HOST, (): void => {
  console.log(`Сервер запущено на http://${HOST}:${PORT}`);
});

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
  res.end('OK');
});

// Подія: сервер почав слухати порт
server.on('listening', (): void => {
  const address = server.address();
  console.log(`Сервер слухає ${address.address}:${address.port}`);
});

// Подія: помилка запуску (наприклад, порт зайнятий)
server.on('error', (error: Error): void => {
  if (error.code === 'EADDRINUSE') {
    console.error(`Порт ${PORT} вже зайнятий іншим процесом`);
    process.exit(1);
  } else if (error.code === 'EACCES') {
    console.error(`Недостатньо прав для прив'язки до порту ${PORT}`);
    process.exit(1);
  } else {
    console.error('Критична помилка сервера:', error);
    process.exit(1);
  }
});

// Подія: нове з'єднання встановлено
server.on('connection', (socket) => {
  console.log('Нове TCP-з\'єднання від', socket.remoteAddress);
});

const PORT = 3000;
server.listen(PORT);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  // Збір інформації про запит
  const info = {
    method: request.method,
    url: request.url,
    httpVersion: request.httpVersion,
    headers: request.headers,
    clientIP: request.socket.remoteAddress,
    clientPort: request.socket.remotePort
  };
  
  // Відправка інформації у форматі JSON
  response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
  response.end(JSON.stringify(info, null, 2));
});

server.listen(3000, (): void => {
  console.log('Інспектор запитів запущено на http://127.0.0.1:3000');
});

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';
import { URL } from 'node:url';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  // Побудова повного URL (потрібна базова адреса для конструктора URL)
  const baseURL = `http://${request.headers.host}`;
  const url: URL = new URL(request.url, baseURL);
  
  // Розбір компонентів URL
  const pathname = url.pathname; // '/api/users'
  const searchParams = url.searchParams; // URLSearchParams об'єкт
  
  // Отримання конкретного параметра
  const page = searchParams.get('page') || '1';
  const limit = searchParams.get('limit') || '10';
  
  // Перевірка наявності параметра
  const hasFilter = searchParams.has('filter');
  
  const result = {
    pathname,
    queryParams: Object.fromEntries(searchParams),
    page: parseInt(page, 10),
    limit: parseInt(limit, 10),
    hasFilter
  };
  
  response.writeHead(200, { 'Content-Type': 'application/json' });
  response.end(JSON.stringify(result, null, 2));
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  // Отримання конкретних заголовків
  const contentType = request.headers['content-type'];
  const userAgent = request.headers['user-agent'];
  const authorization = request.headers['authorization'];
  const acceptLanguage = request.headers['accept-language'];
  
  // Перевірка наявності заголовка
  if (!authorization) {
    response.writeHead(401, { 'Content-Type': 'application/json' });
    response.end(JSON.stringify({ error: 'Authorization header is required' }));
    return;
  }
  
  // Парсинг Bearer токена
  const token = authorization.startsWith('Bearer ')
    ? authorization.slice(7)
    : null;
  
  if (!token) {
    response.writeHead(401, { 'Content-Type': 'application/json' });
    response.end(JSON.stringify({ error: 'Invalid authorization format' }));
    return;
  }
  
  // Симуляція успішної автентифікації
  response.writeHead(200, { 'Content-Type': 'application/json' });
  response.end(JSON.stringify({
    message: 'Authenticated successfully',
    token: token.slice(0, 10) + '...',
    contentType,
    userAgent,
    language: acceptLanguage
  }));
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  // Спосіб 1: writeHead + end з даними
  response.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  response.end('Відповідь відправлено');
  
  // Спосіб 2: setHeader + end
  response.setHeader('Content-Type', 'application/json');
  response.end(JSON.stringify({ message: 'OK' }));
  
  // Спосіб 3: множинні write + end
  response.writeHead(200, { 'Content-Type': 'text/html' });
  response.write('<!DOCTYPE html>');
  response.write('<html><body>');
  response.write('<h1>Привіт</h1>');
  response.write('</body></html>');
  response.end();
  
  // Спосіб 4: лише end (статус 200 за замовчуванням)
  response.end('Простий текст');
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  // Симуляція бази даних користувачів
  const users = [
    { id: 1, name: 'Олександр' },
    { id: 2, name: 'Марія' }
  ];
  
  // Парсинг URL
  const url: URL = new URL(request.url, `http://${request.headers.host}`);
  const userId = parseInt(url.pathname.split('/').pop(), 10);
  
  // GET /api/users/:id
  if (request.method === 'GET' && url.pathname.startsWith('/api/users/')) {
    const user = users.find(u => u.id === userId);
    
    if (user) {
      // 200 OK — ресурс знайдено
      response.writeHead(200, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify(user));
    } else {
      // 404 Not Found — ресурс не існує
      response.writeHead(404, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({
        error: 'User not found',
        userId
      }));
    }
    return;
  }
  
  // POST /api/users — створення користувача
  if (request.method === 'POST' && url.pathname === '/api/users') {
    // 201 Created — новий ресурс створено
    const newUser = { id: users.length + 1, name: 'Новий користувач' };
    users.push(newUser);
    
    response.writeHead(201, {
      'Content-Type': 'application/json',
      'Location': `/api/users/${newUser.id}` // URL нового ресурсу
    });
    response.end(JSON.stringify(newUser));
    return;
  }
  
  // DELETE /api/users/:id — видалення користувача
  if (request.method === 'DELETE' && url.pathname.startsWith('/api/users/')) {
    const index = users.findIndex(u => u.id === userId);
    
    if (index !== -1) {
      users.splice(index, 1);
      // 204 No Content — видалено успішно, немає тіла відповіді
      response.writeHead(204);
      response.end();
    } else {
      response.writeHead(404, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ error: 'User not found' }));
    }
    return;
  }
  
  // Невідомий маршрут або метод
  response.writeHead(404, { 'Content-Type': 'application/json' });
  response.end(JSON.stringify({
    error: 'Route not found',
    path: url.pathname,
    method: request.method
  }));
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  // Метод 1: через writeHead (рекомендовано)
  response.writeHead(200, {
    'Content-Type': 'application/json; charset=utf-8',
    'Cache-Control': 'no-store, no-cache, must-revalidate',
    'X-Custom-Header': 'CustomValue',
    'Access-Control-Allow-Origin': '*',
    'Content-Security-Policy': "default-src 'self'"
  });
  
  // Метод 2: через setHeader (до відправки заголовків)
  response.setHeader('Content-Type', 'text/html; charset=utf-8');
  response.setHeader('X-Powered-By', 'Node.js');
  
  // Видалення заголовка (до відправки)
  response.removeHeader('X-Powered-By');
  
  // Перевірка наявності заголовка
  if (!response.hasHeader('Content-Type')) {
    response.setHeader('Content-Type', 'text/plain');
  }
  
  // Отримання значення заголовка
  const contentType = response.getHeader('Content-Type');
  console.log('Content-Type:', contentType);
  
  response.end(JSON.stringify({ message: 'Headers set' }));
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  const { method, url } = request;
  
  // ❌ Проблема: громіздкий код з вкладеними if/else
  if (method === 'GET') {
    if (url === '/') {
      response.end('Home page');
    } else if (url === '/about') {
      response.end('About page');
    } else if (url === '/users') {
      response.end('Users list');
    } else {
      response.writeHead(404);
      response.end('Not found');
    }
  } else if (method === 'POST') {
    if (url === '/users') {
      response.end('Create user');
    } else {
      response.writeHead(404);
      response.end('Not found');
    }
  } else {
    response.writeHead(405); // Method Not Allowed
    response.end('Method not supported');
  }
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';
import { URL } from 'node:url';

// Карта маршрутів: ключ — "METHOD /path", значення — handler-функція
const routes = {
  'GET /': (req: IncomingMessage, res: ServerResponse) => {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>Головна сторінка</h1>');
  },
  
  'GET /about': (req: IncomingMessage, res: ServerResponse) => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ page: 'About', version: '1.0.0' }));
  },
  
  'GET /api/users': (req: IncomingMessage, res: ServerResponse) => {
    const users = [
      { id: 1, name: 'Олександр' },
      { id: 2, name: 'Марія' }
    ];
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(users));
  },
  
  'POST /api/users': (req: IncomingMessage, res: ServerResponse) => {
    // Тут буде логіка читання тіла запиту (див. наступний розділ)
    res.writeHead(201, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ id: 3, name: 'Новий користувач' }));
  },
  
  'DELETE /api/users': (req: IncomingMessage, res: ServerResponse) => {
    res.writeHead(204); // No Content
    res.end();
  }
};

// Обробник 404
function notFoundHandler(req, res) {
  res.writeHead(404, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    error: 'Route not found',
    path: req.url,
    method: req.method
  }));
}

// Головний обробник запитів
const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  const url: URL = new URL(request.url, `http://${request.headers.host}`);
  const routeKey = `${request.method} ${url.pathname}`;
  
  const handler = routes[routeKey] || notFoundHandler;
  handler(request, response);
});

server.listen(3000, (): void => {
  console.log('Сервер запущено на http://127.0.0.1:3000');
  console.log('Доступні маршрути:');
  Object.keys(routes).forEach(route => console.log(`  ${route}`));
});

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';
import { URL } from 'node:url';

// Функція для співставлення шляху з шаблоном
function matchRoute(pattern, pathname) {
  const patternParts = pattern.split('/').filter(Boolean);
  const pathParts = pathname.split('/').filter(Boolean);
  
  if (patternParts.length !== pathParts.length) {
    return null;
  }
  
  const params = {};
  
  for (let i = 0; i < patternParts.length; i++) {
    const patternPart = patternParts[i];
    const pathPart = pathParts[i];
    
    if (patternPart.startsWith(':')) {
      // Динамічний параметр
      const paramName = patternPart.slice(1);
      params[paramName] = pathPart;
    } else if (patternPart !== pathPart) {
      // Статична частина не співпадає
      return null;
    }
  }
  
  return params;
}

// Маршрути з параметрами
const routes = [
  {
    method: 'GET',
    pattern: '/api/users/:id',
    handler: (req, res, params) => {
      const userId = params.id;
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        message: `Fetching user with ID: ${userId}`,
        userId
      }));
    }
  },
  {
    method: 'PUT',
    pattern: '/api/users/:id',
    handler: (req, res, params) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        message: `Updating user ${params.id}`
      }));
    }
  },
  {
    method: 'GET',
    pattern: '/api/posts/:postId/comments/:commentId',
    handler: (req, res, params) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        postId: params.postId,
        commentId: params.commentId
      }));
    }
  }
];

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  const url: URL = new URL(request.url, `http://${request.headers.host}`);
  
  // Пошук відповідного маршруту
  for (const route of routes) {
    if (route.method !== request.method) {
      continue;
    }
    
    const params = matchRoute(route.pattern, url.pathname);
    
    if (params !== null) {
      route.handler(request, response, params);
      return;
    }
  }
  
  // 404 Not Found
  response.writeHead(404, { 'Content-Type': 'application/json' });
  response.end(JSON.stringify({ error: 'Route not found' }));
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';
import { URL } from 'node:url';

// Симуляція бази даних
let users = [
  { id: 1, name: 'Олександр', email: 'alex@example.com' },
  { id: 2, name: 'Марія', email: 'maria@example.com' }
];

let nextId = 3;

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  const url: URL = new URL(request.url, `http://${request.headers.host}`);
  const { method, pathname } = { method: request.method, pathname: url.pathname };
  
  // GET /api/users — отримання списку користувачів
  if (method === 'GET' && pathname === '/api/users') {
    response.writeHead(200, { 'Content-Type': 'application/json' });
    response.end(JSON.stringify(users));
    return;
  }
  
  // GET /api/users/:id — отримання конкретного користувача
  if (method === 'GET' && pathname.startsWith('/api/users/')) {
    const id = parseInt(pathname.split('/').pop(), 10);
    const user = users.find(u => u.id === id);
    
    if (user) {
      response.writeHead(200, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify(user));
    } else {
      response.writeHead(404, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ error: 'User not found' }));
    }
    return;
  }
  
  // POST /api/users — створення користувача
  if (method === 'POST' && pathname === '/api/users') {
    let body = '';
    
    request.on('data', chunk => {
      body += chunk.toString();
    });
    
    request.on('end', (): void => {
      try {
        const data = JSON.parse(body);
        const newUser = { id: nextId++, ...data };
        users.push(newUser);
        
        response.writeHead(201, {
          'Content-Type': 'application/json',
          'Location': `/api/users/${newUser.id}`
        });
        response.end(JSON.stringify(newUser));
      } catch (error) {
        response.writeHead(400, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: 'Invalid JSON' }));
      }
    });
    return;
  }
  
  // PUT /api/users/:id — повна заміна користувача
  if (method === 'PUT' && pathname.startsWith('/api/users/')) {
    const id = parseInt(pathname.split('/').pop(), 10);
    let body = '';
    
    request.on('data', chunk => {
      body += chunk.toString();
    });
    
    request.on('end', (): void => {
      try {
        const data = JSON.parse(body);
        const index = users.findIndex(u => u.id === id);
        
        if (index !== -1) {
          users[index] = { id, ...data };
          response.writeHead(200, { 'Content-Type': 'application/json' });
          response.end(JSON.stringify(users[index]));
        } else {
          response.writeHead(404, { 'Content-Type': 'application/json' });
          response.end(JSON.stringify({ error: 'User not found' }));
        }
      } catch (error) {
        response.writeHead(400, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: 'Invalid JSON' }));
      }
    });
    return;
  }
  
  // DELETE /api/users/:id — видалення користувача
  if (method === 'DELETE' && pathname.startsWith('/api/users/')) {
    const id = parseInt(pathname.split('/').pop(), 10);
    const index = users.findIndex(u => u.id === id);
    
    if (index !== -1) {
      users.splice(index, 1);
      response.writeHead(204); // No Content
      response.end();
    } else {
      response.writeHead(404, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ error: 'User not found' }));
    }
    return;
  }
  
  // OPTIONS — CORS preflight
  if (method === 'OPTIONS') {
    response.writeHead(204, {
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
      'Access-Control-Allow-Headers': 'Content-Type, Authorization'
    });
    response.end();
    return;
  }
  
  // 404 або 405
  if (pathname.startsWith('/api/')) {
    response.writeHead(405, { 'Content-Type': 'application/json' });
    response.end(JSON.stringify({
      error: 'Method not allowed',
      allowedMethods: ['GET', 'POST', 'PUT', 'DELETE']
    }));
  } else {
    response.writeHead(404, { 'Content-Type': 'application/json' });
    response.end(JSON.stringify({ error: 'Route not found' }));
  }
});

server.listen(3000, (): void => {
  console.log('RESTful API запущено на http://127.0.0.1:3000');
});

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer((request: IncomingMessage, response: ServerResponse) => {
  if (request.method === 'POST' && request.url === '/api/data') {
    let body = ''; // Буфер для накопичення даних
    
    // Подія 'data': отримано частину даних
    request.on('data', (chunk) => {
      body += chunk.toString(); // Конвертація Buffer у рядок
      
      // Захист від переповнення пам'яті
      if (body.length > 1e6) { // 1 МБ ліміт
        request.destroy(); // Розірвати з'єднання
        response.writeHead(413, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: 'Payload too large' }));
      }
    });
    
    // Подія 'end': всі дані отримано
    request.on('end', (): void => {
      try {
        const data = JSON.parse(body);
        console.log('Отримано дані:', data);
        
        response.writeHead(200, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({
          message: 'Data received',
          receivedBytes: body.length,
          data
        }));
      } catch (error) {
        response.writeHead(400, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({
          error: 'Invalid JSON',
          details: error.message
        }));
      }
    });
    
    // Подія 'error': помилка читання (наприклад, розрив з'єднання)
    request.on('error', (error: Error): void => {
      console.error('Request error:', error);
      response.writeHead(500, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ error: 'Request processing failed' }));
    });
    
  } else {
    response.writeHead(404, { 'Content-Type': 'application/json' });
    response.end(JSON.stringify({ error: 'Route not found' }));
  }
});

server.listen(3000);

/**
 * Читає тіло HTTP-запиту та повертає його як рядок
 * @param {http.IncomingMessage} request - HTTP-запит
 * @param {Object} options - Налаштування
 * @param {number} options.maxSize - Максимальний розмір у байтах (за замовчуванням 1 МБ)
 * @param {string} options.encoding - Кодування (за замовчуванням 'utf8')
 * @returns {Promise<string>} - Повне тіло запиту
 */
function readRequestBody(request, { maxSize = 1e6, encoding = 'utf8' } = {}) {
  return new Promise((resolve, reject) => {
    let body = '';
    let size = 0;
    
    request.setEncoding(encoding);
    
    request.on('data', (chunk) => {
      size += chunk.length;
      
      if (size > maxSize) {
        request.destroy();
        reject(new Error(`Payload exceeds maximum size of ${maxSize} bytes`));
        return;
      }
      
      body += chunk;
    });
    
    request.on('end', (): void => {
      resolve(body);
    });
    
    request.on('error', (error: Error): void => {
      reject(error);
    });
  });
}

// Використання з async/await
import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

const server = http.createServer(async (request: IncomingMessage, response: ServerResponse) => {
  if (request.method === 'POST' && request.url === '/api/users') {
    try {
      const body = await readRequestBody(request, { maxSize: 10 * 1024 }); // 10 КБ ліміт
      const data = JSON.parse(body);
      
      // Валідація даних
      if (!data.name || typeof data.name !== 'string') {
        response.writeHead(400, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: 'Name is required and must be a string' }));
        return;
      }
      
      // Обробка валідних даних
      response.writeHead(201, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ message: 'User created', data }));
      
    } catch (error) {
      if (error.message.includes('Payload exceeds')) {
        response.writeHead(413, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: error.message }));
      } else if (error instanceof SyntaxError) {
        response.writeHead(400, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: 'Invalid JSON' }));
      } else {
        console.error('Unexpected error:', error);
        response.writeHead(500, { 'Content-Type': 'application/json' });
        response.end(JSON.stringify({ error: 'Internal server error' }));
      }
    }
  } else {
    response.writeHead(404);
    response.end();
  }
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';
import { parse as parseQueryString } from 'node:querystring';

async function parseRequestBody(request) {
  const contentType = request.headers['content-type'] || '';
  const body = await readRequestBody(request);
  
  // JSON (application/json)
  if (contentType.includes('application/json')) {
    try {
      return { type: 'json', data: JSON.parse(body) };
    } catch (error) {
      throw new Error('Invalid JSON format');
    }
  }
  
  // Form URL-encoded (application/x-www-form-urlencoded)
  if (contentType.includes('application/x-www-form-urlencoded')) {
    return { type: 'form', data: parseQueryString(body) };
  }
  
  // Plain text (text/plain)
  if (contentType.includes('text/plain')) {
    return { type: 'text', data: body };
  }
  
  // Інші типи або відсутність Content-Type
  return { type: 'raw', data: body };
}

const server = http.createServer(async (request: IncomingMessage, response: ServerResponse) => {
  if (request.method === 'POST' && request.url === '/api/submit') {
    try {
      const parsed = await parseRequestBody(request);
      
      response.writeHead(200, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({
        message: 'Data received',
        contentType: parsed.type,
        data: parsed.data
      }));
    } catch (error) {
      response.writeHead(400, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ error: error.message }));
    }
  } else {
    response.writeHead(404);
    response.end();
  }
});

server.listen(3000);

import http from 'node:http';
import type { IncomingMessage, ServerResponse } from 'node:http';

function createJsonResponse(response, statusCode, data) {
  response.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
  response.end(JSON.stringify(data));
}

const server = http.createServer(async (request: IncomingMessage, response: ServerResponse) => {
  if (request.method === 'POST' && request.url === '/api/users') {
    try {
      const body = await readRequestBody(request);
      
      // Спроба парсингу JSON
      let data;
      try {
        data = JSON.parse(body);
      } catch (jsonError) {
        createJsonResponse(response, 400, {
          error: 'Invalid JSON syntax',
          details: jsonError.message,
          position: jsonError.message.match(/position (\d+)/)?.[1]
        });
        return;
      }
      
      // Валідація структури даних
      const errors = [];
      
      if (!data.name) {
        errors.push({ field: 'name', message: 'Name is required' });
      } else if (typeof data.name !== 'string') {
        errors.push({ field: 'name', message: 'Name must be a string' });
      } else if (data.name.length < 2 || data.name.length > 50) {
        errors.push({ field: 'name', message: 'Name must be between 2 and 50 characters' });
      }
      
      if (data.age !== undefined) {
        if (typeof data.age !== 'number' || !Number.isInteger(data.age)) {
          errors.push({ field: 'age', message: 'Age must be an integer' });
        } else if (data.age < 0 || data.age > 150) {
          errors.push({ field: 'age', message: 'Age must be between 0 and 150' });
        }
      }
      
      if (errors.length > 0) {
        createJsonResponse(response, 422, {
          error: 'Validation failed',
          errors
        });
        return;
      }
      
      // Успішна обробка
      createJsonResponse(response, 201, {
        message: 'User created successfully',
        user: data
      });
      
    } catch (error) {
      console.error('Unexpected error:', error);
      createJsonResponse(response, 500, {
        error: 'Internal server error'
      });
    }
  } else {
    createJsonResponse(response, 404, {
      error: 'Route not found'
    });
  }
});

server.listen(3000);

// Спрощена структура Express
class Express {
  constructor() {
    this.routes = [];
    this.middlewares = [];
  }
  
  use(middleware) {
    this.middlewares.push(middleware);
  }
  
  post(path, handler) {
    this.routes.push({ method: 'POST', path, handler });
  }
  
  listen(port) {
    const server = http.createServer(async (req: IncomingMessage, res: ServerResponse) => {
      // 1. Виконання middleware
      for (const middleware of this.middlewares) {
        await middleware(req, res);
      }
      
      // 2. Пошук маршруту
      const route = this.routes.find(r => 
        r.method === req.method && r.path === new URL(req.url, 'http://localhost').pathname
      );
      
      if (route) {
        // 3. Виконання обробника
        await route.handler(req, res);
      } else {
        res.writeHead(404);
        res.end('Not found');
      }
    });
    
    server.listen(port);
  }
}