Building a MERN Stack Application: A Practical Guide with JavaScript

require("dotenv").config();

const express = require("express");
const mongoose = require("mongoose");
const cors = require("cors");

// Initialize the Express application and shared middleware.
const app = express();
const PORT = process.env.PORT || 5000;
const MONGODB_URI = process.env.MONGODB_URI;

app.use(cors());
app.use(express.json());

// Define the shape and validation rules for task documents.
const taskSchema = new mongoose.Schema(
  {
    title: {
      type: String,
      required: [true, "Task title is required"],
      trim: true,
      minlength: [3, "Title must contain at least 3 characters"],
      maxlength: [120, "Title cannot exceed 120 characters"]
    },
    completed: {
      type: Boolean,
      default: false
    }
  },
  { timestamps: true }
);

const Task = mongoose.model("Task", taskSchema);

// Confirm that the API process is responding to requests.
app.get("/api/health", (req, res) => {
  console.log("Step 1: Health check requested");
  res.status(200).json({ status: "ok", message: "Task API is running" });
});

// Retrieve tasks, newest first, with a bounded page size.
app.get("/api/tasks", async (req, res, next) => {
  try {
    console.log("Step 2: Fetching tasks from MongoDB");
    const limit = Math.min(Number.parseInt(req.query.limit, 10) || 20, 100);
    const tasks = await Task.find().sort({ createdAt: -1 }).limit(limit);
    console.log(`Retrieved ${tasks.length} task(s)`);
    res.status(200).json({ count: tasks.length, data: tasks });
  } catch (error) {
    next(error);
  }
});

// Create a task after checking the request payload.
app.post("/api/tasks", async (req, res, next) => {
  try {
    console.log("Step 3: Validating new task payload");
    const { title } = req.body;

    if (typeof title !== "string" || title.trim().length < 3) {
      return res.status(400).json({
        message: "Title must be a string containing at least 3 characters"
      });
    }

    const task = await Task.create({ title: title.trim() });
    console.log(`Created task with ID: ${task._id}`);
    return res.status(201).json({ message: "Task created", data: task });
  } catch (error) {
    return next(error);
  }
});

// Update only the supported fields of an existing task.
app.patch("/api/tasks/:id", async (req, res, next) => {
  try {
    console.log(`Step 4: Updating task ${req.params.id}`);

    if (!mongoose.isValidObjectId(req.params.id)) {
      return res.status(400).json({ message: "Invalid task ID" });
    }

    const updates = {};
    if (typeof req.body.title === "string") {
      updates.title = req.body.title.trim();
    }
    if (typeof req.body.completed === "boolean") {
      updates.completed = req.body.completed;
    }

    if (Object.keys(updates).length === 0) {
      return res.status(400).json({ message: "No valid fields provided" });
    }

    const task = await Task.findByIdAndUpdate(req.params.id, updates, {
      new: true,
      runValidators: true
    });

    if (!task) {
      return res.status(404).json({ message: "Task not found" });
    }

    console.log("Task updated successfully");
    return res.status(200).json({ message: "Task updated", data: task });
  } catch (error) {
    return next(error);
  }
});

// Delete a task by its MongoDB document ID.
app.delete("/api/tasks/:id", async (req, res, next) => {
  try {
    console.log(`Step 5: Deleting task ${req.params.id}`);

    if (!mongoose.isValidObjectId(req.params.id)) {
      return res.status(400).json({ message: "Invalid task ID" });
    }

    const task = await Task.findByIdAndDelete(req.params.id);
    if (!task) {
      return res.status(404).json({ message: "Task not found" });
    }

    console.log("Task deleted successfully");
    return res.status(200).json({ message: "Task deleted" });
  } catch (error) {
    return next(error);
  }
});

// Handle unknown API routes without exposing internal details.
app.use((req, res) => {
  res.status(404).json({ message: "Route not found" });
});

// Convert known validation errors into readable client responses.
app.use((error, req, res, next) => {
  console.error("Request failed:", error.message);

  if (error.name === "ValidationError" || error.name === "CastError") {
    return res.status(400).json({ message: "Invalid request data" });
  }

  return res.status(500).json({ message: "Internal server error" });
});

// Connect to MongoDB before accepting incoming requests.
async function startServer() {
  try {
    if (!MONGODB_URI) {
      throw new Error("MONGODB_URI is missing from environment variables");
    }

    console.log("Step 6: Connecting to MongoDB...");
    await mongoose.connect(MONGODB_URI);
    console.log("MongoDB connected successfully");

    app.listen(PORT, () => {
      console.log(`Step 7: API server listening on port ${PORT}`);
      console.log(`Health endpoint: http://localhost:${PORT}/api/health`);
      console.log(`Tasks endpoint: http://localhost:${PORT}/api/tasks`);
    });
  } catch (error) {
    console.error("Server startup failed:", error.message);
    process.exitCode = 1;
  }
}

// Start the application only after defining routes and middleware.
startServer();