Node.js API разработка: Express vs Fastify vs NestJS

// Установка: npm install express
const express = require('express');
const app = express();

app.use(express.json());

// Простой GET endpoint
app.get('/api/users', async (req, res) => {
  const users = await db.getUsers();
  res.json(users);
});

// POST endpoint с валидацией
app.post('/api/users', async (req, res) => {
  const { name, email } = req.body;
  
  if (!name || !email) {
    return res.status(400).json({ error: 'Name and email required' });
  }
  
  const user = await db.createUser({ name, email });
  res.status(201).json(user);
});

// Middleware для аутентификации
const authenticate = (req, res, next) => {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  req.user = decodeToken(token);
  next();
};

app.get('/api/profile', authenticate, async (req, res) => {
  const profile = await db.getProfile(req.user.id);
  res.json(profile);
});

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

// Установка: npm install fastify
const fastify = require('fastify')({ logger: true });

// JSON Schema для валидации
const userSchema = {
  body: {
    type: 'object',
    required: ['name', 'email'],
    properties: {
      name: { type: 'string', minLength: 2 },
      email: { type: 'string', format: 'email' }
    }
  }
};

// GET endpoint
fastify.get('/api/users', async (request, reply) => {
  const users = await db.getUsers();
  return users;
});

// POST endpoint с автоматической валидацией
fastify.post('/api/users', { schema: userSchema }, async (request, reply) => {
  const { name, email } = request.body;
  const user = await db.createUser({ name, email });
  return reply.status(201).send(user);
});

// Plugin для аутентификации
fastify.register(async function (fastify) {
  fastify.addHook('onRequest', async (request, reply) => {
    const token = request.headers.authorization;
    if (!token) {
      reply.code(401).send({ error: 'Unauthorized' });
      return;
    }
    request.user = decodeToken(token);
  });
});

fastify.get('/api/profile', async (request, reply) => {
  const profile = await db.getProfile(request.user.id);
  return profile;
});

// Запуск сервера
fastify.listen({ port: 3000 }, (err, address) => {
  if (err) throw err;
  console.log(`Server listening on ${address}`);
});

// Установка: npm install @nestjs/common @nestjs/core @nestjs/platform-express

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

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

// app.module.ts
import { Module } from '@nestjs/common';
import { UsersController } from './users/users.controller';
import { UsersService } from './users/users.service';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class AppModule {}

// users.controller.ts
import { Controller, Get, Post, Body } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';

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

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

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
}

// users.service.ts
import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';

@Injectable()
export class UsersService {
  async findAll() {
    return await db.getUsers();
  }

  async create(createUserDto: CreateUserDto) {
    return await db.createUser(createUserDto);
  }
}

// dto/create-user.dto.ts
export class CreateUserDto {
  name: string;
  email: string;
}

const fastify = require('fastify')();
const fastifyExpress = require('@fastify/express');

// Используйте Express middleware в Fastify
fastify.register(fastifyExpress);
fastify.use(expressMiddleware);