nodejs-frameworks

Node.js Framework Patterns

NestJS

// Module
@Module({
  imports: [TypeOrmModule.forFeature([Order])],
  controllers: [OrderController],
  providers: [OrderService, OrderRepository],
})
export class OrderModule {}

// Controller
@Controller("api/v1/orders")
export class OrderController {
  constructor(private readonly orderService: OrderService) {}

  @Post()
  @HttpCode(HttpStatus.CREATED)
  async create(@Body(new ZodValidationPipe(createOrderSchema)) dto: CreateOrderDto) {
    return this.orderService.create(dto);
  }

  @Get(":id")
  async findOne(@Param("id", ParseIntPipe) id: number) {
    return this.orderService.findById(id);
  }
}

// Service
@Injectable()
export class OrderService {
  constructor(private readonly orderRepo: OrderRepository) {}

  async create(dto: CreateOrderDto): Promise<OrderResponse> {
    const order = Order.create(dto);
    await this.orderRepo.save(order);
    return OrderResponse.from(order);
  }
}

Express

const router = Router();

router.post("/api/v1/orders", validate(createOrderSchema), async (req, res, next) => {
  try {
    const order = await orderService.create(req.body);
    res.status(201).json(order);
  } catch (error) {
    next(error);
  }
});

Fastify

app.register(async (fastify) => {
  fastify.post("/api/v1/orders", {
    schema: { body: createOrderSchema },
    handler: async (request, reply) => {
      const order = await orderService.create(request.body);
      reply.code(201).send(order);
    },
  });
});

Validation (Zod)

const createOrderSchema = z.object({
  customerId: z.string().min(1).max(50),
  items: z.array(z.object({
    productId: z.string(),
    quantity: z.number().int().positive(),
  })).min(1),
});

type CreateOrderDto = z.infer<typeof createOrderSchema>;