Building a Full CRUD API for Coupons with Express.js

Introduction

In our Triangulo-bonaerense project, we recently focused on developing a robust system for managing promotional coupons. This involved creating a complete RESTful API that allows for the full spectrum of Create, Read, Update, and Delete (CRUD) operations for coupon entities. This post details the implementation of these API endpoints using Express.js, ensuring efficient and organized coupon management.

The Challenge of Dynamic Coupon Management

Managing dynamic content like promotional coupons is central to many applications. For Triangulo-bonaerense, we needed a flexible backend that could handle various scenarios: adding new coupons, retrieving existing ones for display or validation, modifying coupon details, and removing expired or invalid coupons. The challenge was to build a secure, efficient, and well-structured API that correctly maps HTTP methods to specific database actions, providing a solid foundation for both internal management and front-end integration.

Building the Coupon API with Express.js

Express.js provides a minimalistic yet powerful framework for building web applications and APIs in Node.js. We leveraged its routing capabilities to define clear endpoints for each CRUD operation. This approach ensures that our API is intuitive, maintainable, and adheres to RESTful principles.

Setting up the Express application typically involves initializing the app, enabling JSON body parsing, and defining our routes. For our coupon API, we created a dedicated router for /api/coupons to encapsulate all coupon-related operations.

Implementing CRUD Endpoints

Each core CRUD operation maps directly to an HTTP method. We implemented handlers for GET, POST, PUT, and DELETE requests, interacting with our database abstraction layer (e.g., cupones_db.js) to perform the actual data persistence.

Here’s a simplified example of how we set up some of these endpoints using an Express router, demonstrating GET to retrieve coupons and POST to create them:

// In cupones_api.js
const express = require('express');
const router = express.Router();
// Assume a db module for SQL interactions like 'cupones_db'
const db = require('./cupones_db'); 

// GET all coupons
router.get('/', async (req, res) => {
  try {
    const coupons = await db.findManyCoupons();
    res.status(200).json(coupons);
  } catch (err) {
    console.error(err); // Log the error for debugging
    res.status(500).send('Failed to fetch coupons.');
  }
});

// POST a new coupon
router.post('/', async (req, res) => {
  try {
    const newCouponData = req.body;
    const result = await db.createCoupon(newCouponData);
    res.status(201).json({ message: 'Coupon created', couponId: result.id });
  } catch (err) {
    console.error(err);
    res.status(500).send('Failed to create coupon.');
  }
});

module.exports = router;

// In your main application file (e.g., server.js):
// const app = express();
// app.use(express.json());
// const couponsRouter = require('./cupones_api');
// app.use('/api/coupons', couponsRouter);
// app.listen(3000, () => console.log('Server running on port 3000'));

In this setup:

• GET /api/coupons: Retrieves a list of all available coupons. We also implemented GET /api/coupons/:id to fetch a single coupon by its unique identifier.
• POST /api/coupons: Creates a new coupon entry using data provided in the request body. This typically involves an SQL INSERT statement in the db.createCoupon function.

Similarly, PUT /api/coupons/:id is used to update an existing coupon, typically translating to an SQL UPDATE statement. DELETE /api/coupons/:id handles the removal of a coupon, corresponding to an SQL DELETE operation.

Each of these db methods (findManyCoupons, createCoupon, updateCoupon, deleteCoupon, findCouponById) encapsulates the direct SQL queries, abstracting the database interaction from the Express route handlers.

Key Takeaways

Developing a well-defined RESTful API with explicit CRUD operations is fundamental for managing resources efficiently. By adhering to conventions for HTTP methods and resource naming, we ensure a predictable and scalable API. Always abstract your database interactions through a dedicated module to keep your route handlers clean and testable, separating concerns effectively. Adopt RESTful principles to design clear and predictable APIs, ensuring each endpoint performs a distinct and logical operation.

Generated with Gitvlg.com