import http from 'node:http';
import { parse } from 'node:url';

const server = http.createServer((req, res) => {
  const parsedUrl = parse(req.url || '', true);
  const pathname = parsedUrl.pathname;
  const method = req.method;
  
  // Маршрутизація вручну
  if (pathname === '/users' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ users: [] }));
  } else if (pathname?.startsWith('/users/') && method === 'GET') {
    const id = pathname.split('/')[2];
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ id, name: 'Користувач' }));
  } else if (pathname === '/users' && method === 'POST') {
    let body = '';
    
    req.on('data', (chunk) => {
      body += chunk.toString();
    });
    
    req.on('end', () => {
      try {
        const userData = JSON.parse(body);
        // Валідація вручну
        if (!userData.email || !userData.password) {
          res.writeHead(400, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ error: 'Email та пароль обов\'язкові' }));
          return;
        }
        
        res.writeHead(201, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ id: 1, ...userData }));
      } catch (error) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'Невалідний JSON' }));
      }
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: 'Not Found' }));
  }
});

server.listen(3000, () => {
  console.log('Сервер запущено на порту 3000');
});

import express, { Request, Response, NextFunction } from 'express';

const app = express();

// Middleware: парсинг JSON body
app.use(express.json());

// Middleware: логування запитів
app.use((req: Request, res: Response, next: NextFunction) => {
  console.log(`${req.method} ${req.path}`);
  next();
});

// Роут: отримання користувача за ID
app.get('/users/:id', (req: Request, res: Response) => {
  const { id } = req.params;
  res.json({ id, name: 'Користувач', email: 'user@example.com' });
});

// Роут: створення користувача
app.post('/users', (req: Request, res: Response) => {
  const { email, password } = req.body;
  
  // Валідація вручну
  if (!email || !password) {
    return res.status(400).json({ error: 'Email та пароль обов\'язкові' });
  }
  
  res.status(201).json({ id: 1, email });
});

// Error handler (останній middleware)
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  console.error('Error:', err.stack);
  res.status(500).json({ error: 'Internal Server Error' });
});

app.listen(3000, () => {
  console.log('Express сервер запущено на порту 3000');
});

// src/app.ts — Конфігурація Express
import express from 'express';
import helmet from 'helmet';
import cors from 'cors';
import morgan from 'morgan';
import { userRoutes } from './routes/user.routes';
import { errorHandler } from './middleware/error.middleware';

export function createApp() {
  const app = express();
  
  // Security middleware
  app.use(helmet());
  app.use(cors());
  
  // Logging
  app.use(morgan('combined'));
  
  // Body parsing
  app.use(express.json());
  app.use(express.urlencoded({ extended: true }));
  
  // Routes
  app.use('/api/users', userRoutes);
  
  // Error handling
  app.use(errorHandler);
  
  return app;
}

// src/routes/user.routes.ts — Маршрути
import { Router } from 'express';
import { UserController } from '../controllers/user.controller';

export const userRoutes = Router();
const controller = new UserController();

userRoutes.get('/', controller.list);
userRoutes.get('/:id', controller.getById);
userRoutes.post('/', controller.create);
userRoutes.put('/:id', controller.update);
userRoutes.delete('/:id', controller.delete);

// src/controllers/user.controller.ts — Контролери
import { Request, Response, NextFunction } from 'express';
import { UserService } from '../services/user.service';

export class UserController {
  private service = new UserService();
  
  list = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const users = await this.service.findAll();
      res.json(users);
    } catch (error) {
      next(error);
    }
  };
  
  getById = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const user = await this.service.findById(req.params.id);
      if (!user) {
        return res.status(404).json({ error: 'User not found' });
      }
      res.json(user);
    } catch (error) {
      next(error);
    }
  };
  
  create = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const user = await this.service.create(req.body);
      res.status(201).json(user);
    } catch (error) {
      next(error);
    }
  };
  
  // ... update, delete
}

import Fastify, { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';

const server: FastifyInstance = Fastify({
  logger: true, // Вбудований logger (Pino)
});

// Схема валідації для POST /users
const createUserSchema = {
  body: {
    type: 'object',
    required: ['email', 'password'],
    properties: {
      email: { type: 'string', format: 'email' },
      password: { type: 'string', minLength: 8 },
    },
  },
  response: {
    201: {
      type: 'object',
      properties: {
        id: { type: 'number' },
        email: { type: 'string' },
      },
    },
  },
};

// Роут з валідацією
server.post('/users', {
  schema: createUserSchema, // Автоматична валідація!
}, async (request: FastifyRequest<{ Body: { email: string; password: string } }>, reply: FastifyReply) => {
  const { email, password } = request.body;
  
  // Тіло вже валідоване — email гарантовано валідний, password >= 8 символів
  const user = { id: 1, email };
  
  return reply.status(201).send(user); // Автоматична серіалізація за response schema
});

// Роут з параметрами
server.get('/users/:id', async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
  const { id } = request.params;
  return { id, name: 'Користувач', email: 'user@example.com' };
});

// Запуск сервера
server.listen({ port: 3000 }, (err, address) => {
  if (err) {
    server.log.error(err);
    process.exit(1);
  }
  console.log(`Fastify сервер запущено: ${address}`);
});

const getUserSchema = {
  params: {
    type: 'object',
    required: ['id'],
    properties: {
      id: { type: 'string', pattern: '^[0-9]+$' }, // Лише числа
    },
  },
  querystring: {
    type: 'object',
    properties: {
      fields: { type: 'string' }, // Опціональний query параметр
    },
  },
  response: {
    200: {
      type: 'object',
      properties: {
        id: { type: 'number' },
        name: { type: 'string' },
        email: { type: 'string', format: 'email' },
      },
    },
    404: {
      type: 'object',
      properties: {
        error: { type: 'string' },
      },
    },
  },
};

server.get('/users/:id', {
  schema: getUserSchema,
}, async (request, reply) => {
  const { id } = request.params;
  const user = await findUserById(id);
  
  if (!user) {
    return reply.status(404).send({ error: 'User not found' });
  }
  
  // Fastify автоматично серіалізує відповідь за schema 200
  // Зайві поля будуть видалені, типи перевірені
  return user;
});

// src/app.ts — Головний файл застосунку
import Fastify, { FastifyInstance } from 'fastify';
import cors from '@fastify/cors';
import helmet from '@fastify/helmet';
import { userRoutes } from './routes/user.routes';
import { errorHandler } from './plugins/error-handler';

export async function buildApp(): Promise<FastifyInstance> {
  const app = Fastify({
    logger: {
      level: process.env.LOG_LEVEL || 'info',
    },
  });
  
  // Реєстрація плагінів
  await app.register(cors, { origin: true });
  await app.register(helmet);
  await app.register(errorHandler);
  
  // Реєстрація роутів (як плагін)
  await app.register(userRoutes, { prefix: '/api/users' });
  
  return app;
}

// src/routes/user.routes.ts — Роути як плагін
import { FastifyInstance } from 'fastify';
import { UserController } from '../controllers/user.controller';

export async function userRoutes(app: FastifyInstance) {
  const controller = new UserController();
  
  app.get('/', {
    schema: {
      response: {
        200: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              id: { type: 'number' },
              email: { type: 'string' },
            },
          },
        },
      },
    },
  }, controller.list);
  
  app.post('/', {
    schema: {
      body: {
        type: 'object',
        required: ['email', 'password'],
        properties: {
          email: { type: 'string', format: 'email' },
          password: { type: 'string', minLength: 8 },
        },
      },
    },
  }, controller.create);
}

// src/plugins/error-handler.ts — Custom error handler
import { FastifyInstance, FastifyError, FastifyRequest, FastifyReply } from 'fastify';
import fp from 'fastify-plugin';

async function errorHandlerPlugin(app: FastifyInstance) {
  app.setErrorHandler((error: FastifyError, request: FastifyRequest, reply: FastifyReply) => {
    request.log.error(error);
    
    // Валідаційна помилка (400)
    if (error.validation) {
      return reply.status(400).send({
        error: 'Validation Error',
        details: error.validation,
      });
    }
    
    // Інші помилки
    const statusCode = error.statusCode || 500;
    reply.status(statusCode).send({
      error: error.message || 'Internal Server Error',
    });
  });
}

export const errorHandler = fp(errorHandlerPlugin);

// src/server.ts — Entry point
import { buildApp } from './app';

async function start() {
  const app = await buildApp();
  
  try {
    await app.listen({ port: 3000, host: '0.0.0.0' });
    console.log('Server ready at http://localhost:3000');
  } catch (err) {
    app.log.error(err);
    process.exit(1);
  }
}

start();

import Koa, { Context, Next } from 'koa';
import Router from '@koa/router';
import bodyParser from 'koa-bodyparser';

const app = new Koa();
const router = new Router();

// Middleware: логування (виконується "вниз" та "вгору")
app.use(async (ctx: Context, next: Next) => {
  const start = Date.now();
  await next(); // Передаємо управління наступному middleware
  const ms = Date.now() - start;
  console.log(`${ctx.method} ${ctx.url} - ${ms}ms`);
});

// Middleware: обробка помилок
app.use(async (ctx: Context, next: Next) => {
  try {
    await next();
  } catch (error) {
    ctx.status = (error as any).status || 500;
    ctx.body = { error: (error as Error).message };
    ctx.app.emit('error', error, ctx); // Емітуємо подію для централізованого логування
  }
});

// Парсинг body (зовнішній пакет)
app.use(bodyParser());

// Роути
router.get('/users/:id', async (ctx: Context) => {
  const { id } = ctx.params;
  ctx.body = { id, name: 'Користувач', email: 'user@example.com' };
});

router.post('/users', async (ctx: Context) => {
  const { email, password } = ctx.request.body;
  
  // Валідація вручну
  if (!email || !password) {
    ctx.throw(400, 'Email та пароль обов\'язкові');
  }
  
  ctx.status = 201;
  ctx.body = { id: 1, email };
});

// Реєстрація роутів
app.use(router.routes());
app.use(router.allowedMethods());

// Централізований обробник помилок
app.on('error', (err, ctx) => {
  console.error('Server Error:', err);
});

app.listen(3000, () => {
  console.log('Koa сервер запущено на порту 3000');
});

app.use(async (ctx, next) => {
  console.log('1. Перед обробкою запиту');
  await next(); // Передаємо управління наступному middleware
  console.log('6. Після обробки запиту (на зворотньому шляху)');
});

app.use(async (ctx, next) => {
  console.log('2. Другий middleware (вниз)');
  await next();
  console.log('5. Другий middleware (вгору)');
});

app.use(async (ctx, next) => {
  console.log('3. Третій middleware (вниз)');
  ctx.body = 'Hello, Koa!';
  console.log('4. Третій middleware (обробка завершена)');
});

// Вивід при запиті:
// 1. Перед обробкою запиту
// 2. Другий middleware (вниз)
// 3. Третій middleware (вниз)
// 4. Третій middleware (обробка завершена)
// 5. Другий middleware (вгору)
// 6. Після обробки запиту (на зворотньому шляху)

import Hapi from '@hapi/hapi';
import Joi from 'joi';

const server = Hapi.server({
  port: 3000,
  host: 'localhost',
});

// Роут з валідацією через Joi
server.route({
  method: 'GET',
  path: '/users/{id}',
  options: {
    validate: {
      params: Joi.object({
        id: Joi.number().integer().min(1).required(),
      }),
    },
    handler: async (request, h) => {
      const { id } = request.params;
      return { id, name: 'Користувач', email: 'user@example.com' };
    },
  },
});

server.route({
  method: 'POST',
  path: '/users',
  options: {
    validate: {
      payload: Joi.object({
        email: Joi.string().email().required(),
        password: Joi.string().min(8).required(),
      }),
    },
    handler: async (request, h) => {
      const { email, password } = request.payload as any;
      return h.response({ id: 1, email }).code(201);
    },
  },
});

// Запуск сервера
(async () => {
  await server.start();
  console.log('Hapi сервер запущено:', server.info.uri);
})();

// src/users/users.controller.ts — Контролер
import { Controller, Get, Post, Body, Param, HttpCode } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}
  
  @Get()
  findAll() {
    return this.usersService.findAll();
  }
  
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(+id);
  }
  
  @Post()
  @HttpCode(201)
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
}

// src/users/users.service.ts — Сервіс (бізнес-логіка)
import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';

@Injectable()
export class UsersService {
  private users = [];
  
  findAll() {
    return this.users;
  }
  
  findOne(id: number) {
    return this.users.find((u) => u.id === id);
  }
  
  create(createUserDto: CreateUserDto) {
    const user = { id: this.users.length + 1, ...createUserDto };
    this.users.push(user);
    return user;
  }
}

// src/users/dto/create-user.dto.ts — DTO з валідацією
import { IsEmail, IsString, MinLength } from 'class-validator';

export class CreateUserDto {
  @IsEmail()
  email: string;
  
  @IsString()
  @MinLength(8)
  password: string;
}

// src/users/users.module.ts — Модуль
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService], // Експортуємо для використання в інших модулях
})
export class UsersModule {}

// src/app.module.ts — Кореневий модуль
import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';

@Module({
  imports: [UsersModule],
})
export class AppModule {}

// src/main.ts — Entry point
import { NestFactory } from '@nestjs/core';
import { ValidationPipe } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // Глобальна валідація через class-validator
  app.useGlobalPipes(new ValidationPipe());
  
  await app.listen(3000);
  console.log('NestJS застосунок запущено на порту 3000');
}

bootstrap();

// src/database/database.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class DatabaseService {
  async query(sql: string) {
    // Реалізація
  }
}

// src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { DatabaseService } from '../database/database.service';

@Injectable()
export class UsersService {
  // DatabaseService автоматично ін'єктується
  constructor(private db: DatabaseService) {}
  
  async findAll() {
    return this.db.query('SELECT * FROM users');
  }
}

// src/users/users.module.ts
import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { DatabaseService } from '../database/database.service';

@Module({
  providers: [UsersService, DatabaseService],
})
export class UsersModule {}

// Express
app.get('/users/:id', (req, res) => {
  res.json({ id: req.params.id });
});

// Fastify
server.get('/users/:id', async (request, reply) => {
  return { id: request.params.id };
});

// Express
app.get('/users/:id', userController.getById);

// NestJS
@Controller('users')
export class UsersController {
  @Get(':id')
  getById(@Param('id') id: string) {
    return this.usersService.findOne(+id);
  }
}