HTTP Methods and Status Codes

Exercise: Build a Task Management API with Proper HTTP Methods and Status Codes

Create a RESTful API for managing tasks, implementing all the HTTP methods correctly with appropriate status codes and error handling.

Step 1: Setup Project

mkdir task-manager-api
cd task-manager-api
npm init -y
npm install express uuid cors morgan

Step 2: Create the Main Application File

Create a file named app.js:

const express = require('express');
const morgan = require('morgan');
const cors = require('cors');
const { v4: uuidv4 } = require('uuid');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware
app.use(cors());
app.use(morgan('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

// In-memory data store
let tasks = [
  {
    id: '1',
    title: 'Complete project proposal',
    description: 'Finish the client proposal with cost estimates',
    status: 'in-progress',
    priority: 'high',
    dueDate: '2025-05-15',
    createdAt: '2025-05-01T10:30:00Z'
  },
  {
    id: '2',
    title: 'Buy groceries',
    description: 'Milk, eggs, bread, and vegetables',
    status: 'pending',
    priority: 'medium',
    dueDate: '2025-05-05',
    createdAt: '2025-05-01T11:45:00Z'
  },
  {
    id: '3',
    title: 'Schedule team meeting',
    description: 'Quarterly planning session with the development team',
    status: 'completed',
    priority: 'high',
    dueDate: '2025-05-02',
    createdAt: '2025-04-28T09:15:00Z',
    completedAt: '2025-05-02T14:20:00Z'
  }
];

// Custom error class
class ApiError extends Error {
  constructor(statusCode, message, details = null) {
    super(message);
    this.statusCode = statusCode;
    this.details = details;
  }
}

// GET all tasks (with filtering, sorting, and pagination)
app.get('/api/tasks', (req, res) => {
  try {
    // Extract query parameters
    const { 
      status, 
      priority, 
      search,
      sort = 'createdAt', 
      order = 'desc',
      page = 1,
      limit = 10
    } = req.query;
    
    // Filter tasks
    let filteredTasks = [...tasks];
    
    if (status) {
      filteredTasks = filteredTasks.filter(task => 
        task.status === status
      );
    }
    
    if (priority) {
      filteredTasks = filteredTasks.filter(task => 
        task.priority === priority
      );
    }
    
    if (search) {
      const searchLower = search.toLowerCase();
      filteredTasks = filteredTasks.filter(task => 
        task.title.toLowerCase().includes(searchLower) || 
        (task.description && task.description.toLowerCase().includes(searchLower))
      );
    }
    
    // Sort tasks
    filteredTasks.sort((a, b) => {
      const aValue = a[sort];
      const bValue = b[sort];
      
      if (order.toLowerCase() === 'asc') {
        return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
      } else {
        return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
      }
    });
    
    // Paginate
    const startIndex = (parseInt(page) - 1) * parseInt(limit);
    const endIndex = startIndex + parseInt(limit);
    const paginatedTasks = filteredTasks.slice(startIndex, endIndex);
    
    // Prepare pagination metadata
    const totalTasks = filteredTasks.length;
    const totalPages = Math.ceil(totalTasks / parseInt(limit));
    
    res.status(200).json({
      data: paginatedTasks,
      meta: {
        totalTasks,
        currentPage: parseInt(page),
        totalPages,
        limit: parseInt(limit)
      }
    });
  } catch (error) {
    console.error('Error getting tasks:', error);
    res.status(500).json({
      error: 'Internal Server Error',
      message: error.message
    });
  }
});

// GET a specific task by ID
app.get('/api/tasks/:id', (req, res) => {
  try {
    const task = tasks.find(t => t.id === req.params.id);
    
    if (!task) {
      return res.status(404).json({
        error: 'Not Found',
        message: `Task with ID ${req.params.id} not found`
      });
    }
    
    res.status(200).json(task);
  } catch (error) {
    console.error('Error getting task:', error);
    res.status(500).json({
      error: 'Internal Server Error',
      message: error.message
    });
  }
});

// POST a new task
app.post('/api/tasks', (req, res) => {
  try {
    const { title, description, status, priority, dueDate } = req.body;
    
    // Validate required fields
    if (!title) {
      return res.status(400).json({
        error: 'Bad Request',
        message: 'Title is required'
      });
    }
    
    // Validate status if provided
    if (status && !['pending', 'in-progress', 'completed'].includes(status)) {
      return res.status(400).json({
        error: 'Bad Request',
        message: 'Status must be pending, in-progress, or completed'
      });
    }
    
    // Validate priority if provided
    if (priority && !['low', 'medium', 'high'].includes(priority)) {
      return res.status(400).json({
        error: 'Bad Request',
        message: 'Priority must be low, medium, or high'
      });
    }
    
    // Create new task
    const newTask = {
      id: uuidv4(),
      title,
      description: description || '',
      status: status || 'pending',
      priority: priority || 'medium',
      dueDate: dueDate || null,
      createdAt: new Date().toISOString(),
      ...(status === 'completed' ? { completedAt: new Date().toISOString() } : {})
    };
    
    // Add to collection
    tasks.push(newTask);
    
    // Return 201 Created with the new task
    res.status(201)
       .location(`/api/tasks/${newTask.id}`)
       .json(newTask);
  } catch (error) {
    console.error('Error creating task:', error);
    res.status(500).json({
      error: 'Internal Server Error',
      message: error.message
    });

    // PUT (replace) a task
    app.put('/api/tasks/:id', (req, res) => {
      try {
        const { title, description, status, priority, dueDate } = req.body;
        
        // Validate required fields
        if (!title) {
          return res.status(400).json({
            error: 'Bad Request',
            message: 'Title is required'
          });
        }
        
        // Validate status if provided
        if (status && !['pending', 'in-progress', 'completed'].includes(status)) {
          return res.status(400).json({
            error: 'Bad Request',
            message: 'Status must be pending, in-progress, or completed'
          });
        }
        
        // Validate priority if provided
        if (priority && !['low', 'medium', 'high'].includes(priority)) {
          return res.status(400).json({
            error: 'Bad Request',
            message: 'Priority must be low, medium, or high'
          });
        }
        
        // Check if task exists
        const taskIndex = tasks.findIndex(t => t.id === req.params.id);
        
        if (taskIndex === -1) {
          return res.status(404).json({
            error: 'Not Found',
            message: `Task with ID ${req.params.id} not found`
          });
        }
        
        // Preserve creation time from original task
        const { createdAt } = tasks[taskIndex];
        
        // Replace task completely (this is PUT semantics)
        const updatedTask = {
          id: req.params.id,
          title,
          description: description || '',
          status: status || 'pending',
          priority: priority || 'medium',
          dueDate: dueDate || null,
          createdAt,
          updatedAt: new Date().toISOString(),
          ...(status === 'completed' ? { completedAt: new Date().toISOString() } : {})
        };
        
        // Update collection
        tasks[taskIndex] = updatedTask;
        
        // Return 200 OK with updated task
        res.status(200).json(updatedTask);
      } catch (error) {
        console.error('Error updating task:', error);
        res.status(500).json({
          error: 'Internal Server Error',
          message: error.message
        });
      }
    });
    // PATCH (partially update) a task
    app.patch('/api/tasks/:id', (req, res) => {
      try {
        // Check if task exists
        const taskIndex = tasks.findIndex(t => t.id === req.params.id);
        
        if (taskIndex === -1) {
          return res.status(404).json({
            error: 'Not Found',
            message: `Task with ID ${req.params.id} not found`
          });
        }
        
        const existingTask = tasks[taskIndex];
        
        // Validate status if provided
        if (req.body.status && !['pending', 'in-progress', 'completed'].includes(req.body.status)) {
          return res.status(400).json({
            error: 'Bad Request',
            message: 'Status must be pending, in-progress, or completed'
          });
        }
        
        // Validate priority if provided
        if (req.body.priority && !['low', 'medium', 'high'].includes(req.body.priority)) {
          return res.status(400).json({
            error: 'Bad Request',
            message: 'Priority must be low, medium, or high'
          });
        }
        
        // Check if status is being changed to completed
        const isCompletingTask = 
          req.body.status === 'completed' && 
          existingTask.status !== 'completed';
        
        // Update task (partial update, preserving existing fields)
        const updatedTask = {
          ...existingTask,
          ...req.body,
          id: req.params.id,  // Ensure ID doesn't change
          updatedAt: new Date().toISOString(),
          ...(isCompletingTask ? { completedAt: new Date().toISOString() } : {})
        };
        
        // Update collection
        tasks[taskIndex] = updatedTask;
        
        // Return 200 OK with updated task
        res.status(200).json(updatedTask);
      } catch (error) {
        console.error('Error updating task:', error);
        res.status(500).json({
          error: 'Internal Server Error',
          message: error.message
        });
      }
    });
    
    // DELETE a task
    app.delete('/api/tasks/:id', (req, res) => {
      try {
        // Check if task exists
        const taskIndex = tasks.findIndex(t => t.id === req.params.id);
        
        if (taskIndex === -1) {
          return res.status(404).json({
            error: 'Not Found',
            message: `Task with ID ${req.params.id} not found`
          });
        }
        
        // Remove from collection
        tasks.splice(taskIndex, 1);
        
        // Return 204 No Content (success but no content to return)
        res.status(204).end();
      } catch (error) {
        console.error('Error deleting task:', error);
        res.status(500).json({
          error: 'Internal Server Error',
          message: error.message
        });
      }
    });
    
    // POST to mark a task as completed (action endpoint)
    app.post('/api/tasks/:id/complete', (req, res) => {
      try {
        // Check if task exists
        const taskIndex = tasks.findIndex(t => t.id === req.params.id);
        
        if (taskIndex === -1) {
          return res.status(404).json({
            error: 'Not Found',
            message: `Task with ID ${req.params.id} not found`
          });
        }
        
        const task = tasks[taskIndex];
        
        // Check if task is already completed
        if (task.status === 'completed') {
          return res.status(409).json({
            error: 'Conflict',
            message: 'Task is already completed'
          });
        }
        
        // Update task
        const updatedTask = {
          ...task,
          status: 'completed',
          completedAt: new Date().toISOString(),
          updatedAt: new Date().toISOString()
        };
        
        // Update collection
        tasks[taskIndex] = updatedTask;
        
        // Return 200 OK with updated task
        res.status(200).json(updatedTask);
      } catch (error) {
        console.error('Error completing task:', error);
        res.status(500).json({
          error: 'Internal Server Error',
          message: error.message
        });
      }
    });
    
    // Handle 404 - Route not found
    app.use((req, res) => {
      res.status(404).json({
        error: 'Not Found',
        message: `Route ${req.originalUrl} not found`,
        timestamp: new Date().toISOString(),
        path: req.originalUrl
      });
    });
    
    // Global error handler
    app.use((err, req, res, next) => {
      console.error(err.stack);
      
      // Handle custom API errors
      if (err instanceof ApiError) {
        return res.status(err.statusCode).json({
          error: getErrorTitle(err.statusCode),
          message: err.message,
          details: err.details,
          timestamp: new Date().toISOString(),
          path: req.originalUrl
        });
      }
      
      // Default error response for uncaught errors
      res.status(500).json({
        error: 'Internal Server Error',
        message: 'Something went wrong on the server',
        timestamp: new Date().toISOString(),
        path: req.originalUrl
      });
    });
    
    // Helper function to get error titles
    function getErrorTitle(statusCode) {
      const titles = {
        400: 'Bad Request',
        401: 'Unauthorized',
        403: 'Forbidden',
        404: 'Not Found',
        409: 'Conflict',
        422: 'Unprocessable Entity',
        429: 'Too Many Requests',
        500: 'Internal Server Error'
      };
      
      return titles[statusCode] || 'Error';
    }
    
    // Start the server
    app.listen(PORT, () => {
      console.log(`Server running on port ${PORT}`);
    });
    
    module.exports = app;

Step 3: Test the API

Use Postman or a similar tool to test the API endpoints. Ensure all HTTP methods and status codes are implemented correctly.

Step 4: Bonus Challenges

Implement additional features such as authentication, rate limiting, ETag support, and input validation.

Step 5: Submit Your Code

Once completed, submit your code for review.