/design-rest-api

Design REST API

Design RESTful API architecture

Instructions

1. **API Design Strategy and Planning**

• Analyze business requirements and define API scope
• Identify resources, entities, and their relationships
• Plan API versioning strategy and backward compatibility
• Define authentication and authorization requirements
• Plan for scalability, rate limiting, and performance

2. **RESTful Resource Design**

• Design RESTful endpoints following REST principles:

**Express.js API Structure:**

   // routes/api/v1/index.js
   const express = require('express');
   const router = express.Router();

   // Resource-based routing structure
   const userRoutes = require('./users');
   const productRoutes = require('./products');
   const orderRoutes = require('./orders');
   const authRoutes = require('./auth');

   // API versioning and middleware
   router.use('/auth', authRoutes);
   router.use('/users', userRoutes);
   router.use('/products', productRoutes);
   router.use('/orders', orderRoutes);

   module.exports = router;

   // routes/api/v1/users.js
   const express = require('express');
   const router = express.Router();
   const { validateRequest, authenticate, authorize } = require('../../../middleware');
   const userController = require('../../../controllers/userController');
   const userValidation = require('../../../validations/userValidation');

   // User resource endpoints
   router.get('/', 
     authenticate,
     authorize(['admin', 'manager']),
     validateRequest(userValidation.listUsers),
     userController.listUsers
   );

   router.get('/:id', 
     authenticate,
     validateRequest(userValidation.getUser),
     userController.getUser
   );

   router.post('/',
     authenticate,
     authorize(['admin']),
     validateRequest(userValidation.createUser),
     userController.createUser
   );

   router.put('/:id',
     authenticate,
     validateRequest(userValidation.updateUser),
     userController.updateUser
   );

   router.patch('/:id',
     authenticate,
     validateRequest(userValidation.patchUser),
     userController.patchUser
   );

   router.delete('/:id',
     authenticate,
     authorize(['admin']),
     validateRequest(userValidation.deleteUser),
     userController.deleteUser
   );

   // Nested resource endpoints
   router.get('/:id/orders',
     authenticate,
     validateRequest(userValidation.getUserOrders),
     userController.getUserOrders
   );

   router.get('/:id/profile',
     authenticate,
     validateRequest(userValidation.getUserProfile),
     userController.getUserProfile
   );

   module.exports = router;

3. **Request/Response Data Models**

• Define comprehensive data models and validation:

**Data Validation with Joi:**

   // validations/userValidation.js
   const Joi = require('joi');

   const userSchema = {
     create: Joi.object({
       email: Joi.string().email().required(),
       password: Joi.string().min(8).pattern(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/).required(),
       firstName: Joi.string().trim().min(1).max(100).required(),
       lastName: Joi.string().trim().min(1).max(100).required(),
       phone: Joi.string().pattern(/^\+?[\d\s\-\(\)]{10,20}$/).optional(),
       dateOfBirth: Joi.date().max('now').optional(),
       role: Joi.string().valid('user', 'admin', 'manager').default('user')
     }),

     update: Joi.object({
       email: Joi.string().email().optional(),
       firstName: Joi.string().trim().min(1).max(100).optional(),
       lastName: Joi.string().trim().min(1).max(100).optional(),
       phone: Joi.string().pattern(/^\+?[\d\s\-\(\)]{10,20}$/).optional(),
       dateOfBirth: Joi.date().max('now').optional(),
       status: Joi.string().valid('active', 'inactive', 'suspended').optional()
     }),

     list: Joi.object({
       page: Joi.number().integer().min(1).default(1),
       limit: Joi.number().integer().min(1).max(100).default(20),
       sort: Joi.string().valid('id', 'email', 'firstName', 'lastName', 'createdAt').default('id'),
       order: Joi.string().valid('asc', 'desc').default('asc'),
       search: Joi.string().trim().min(1).optional(),
       status: Joi.string().valid('active', 'inactive', 'suspended').optional(),
       role: Joi.string().valid('user', 'admin', 'manager').optional()
     }),

     params: Joi.object({
       id: Joi.number().integer().positive().required()
     })
   };

   const validateRequest = (schema) => {
     return (req, res, next) => {
       const validationTargets = {
         body: req.body,
         query: req.query,
         params: req.params
       };

       const errors = {};

       // Validate each part of the request
       Object.keys(schema).forEach(target => {
         const { error, value } = schema[target].validate(validationTargets[target], {
           abortEarly: false,
           allowUnknown: false,
           stripUnknown: true
         });

         if (error) {
           errors[target] = error.details.map(detail => ({
             field: detail.path.join('.'),
             message: detail.message,
             value: detail.context.value
           }));
         } else {
           req[target] = value;
         }
       });

       if (Object.keys(errors).length > 0) {
         return res.status(400).json({
           error: 'Validation failed',
           details: errors,
           timestamp: new Date().toISOString()
         });
       }

       next();
     };
   };

   module.exports = {
     listUsers: validateRequest({ query: userSchema.list }),
     getUser: validateRequest({ params: userSchema.params }),
     createUser: validateRequest({ body: userSchema.create }),
     updateUser: validateRequest({ 
       params: userSchema.params, 
       body: userSchema.update 
     }),
     patchUser: validateRequest({ 
       params: userSchema.params, 
       body: userSchema.update 
     }),
     deleteUser: validateRequest({ params: userSchema.params }),