Developing the Backend with Node.js

First things first, let’s get your Express server up and running.

1. Create the Server Directory:

Start by creating a new directory for your server, if you haven’t already:

mkdir server && cd server
npm init -y

2. Install Required Dependencies:

You’ll need a few packages to set up your server. Install them with:

npm install express mongoose dotenv
npm install --save-dev nodemon

• Express: A web framework for Node.js that simplifies the process of building a server.
• Mongoose: A library to manage MongoDB connections and schemas.
• Dotenv: For loading environment variables from a .env file.
• Nodemon: A tool that automatically restarts your server when files change during development.

3. Set Up a Basic Express Server:

Create an index.js file in your src folder and set up a simple server:

// server/src/index.js
require('dotenv').config();
const express = require('express');
const mongoose = require('mongoose');

const app = express();
app.use(express.json());

// Basic route
app.get('/', (req, res) => {
  res.send('API is running...');
});

// Connect to MongoDB
mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('MongoDB connected'))
  .catch(err => console.error('Database connection error:', err));

// Start the server
const PORT = process.env.PORT || 5000;
app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});

4. Set Up Environment Variables:

Create a .env file in the root of your project to store environment-specific configurations:

MONGO_URI=your-mongodb-connection-string
PORT=5000

5. Run the Server:

Now, you can start the server using nodemon, which will restart automatically if you make changes:

npm run dev

Your server should now be running at http://localhost:5000.

With your server up, the next step is to design and implement the API endpoints that your application will use.

1. Plan Your Endpoints:

Start by deciding what kind of operations your application needs. For example, in a task manager app, you might have endpoints to create, read, update, and delete tasks.

2. Set Up Routes:

Create a routes directory and a tasks.js file inside it:

mkdir src/routes
touch src/routes/tasks.js

In tasks.js, define the routes:

// server/src/routes/tasks.js
const express = require('express');
const router = express.Router();

// Example tasks array (this would normally be in a database)
let tasks = [
  { id: 1, title: 'Task 1', completed: false },
  { id: 2, title: 'Task 2', completed: true }
];

// GET all tasks
router.get('/', (req, res) => {
  res.json(tasks);
});

// GET a single task by ID
router.get('/:id', (req, res) => {
  const task = tasks.find(t => t.id === parseInt(req.params.id));
  if (!task) return res.status(404).json({ message: 'Task not found' });
  res.json(task);
});

// POST a new task
router.post('/', (req, res) => {
  const newTask = {
    id: tasks.length + 1,
    title: req.body.title,
    completed: false
  };
  tasks.push(newTask);
  res.status(201).json(newTask);
});

// PUT update a task
router.put('/:id', (req, res) => {
  const task = tasks.find(t => t.id === parseInt(req.params.id));
  if (!task) return res.status(404).json({ message: 'Task not found' });

  task.title = req.body.title || task.title;
  task.completed = req.body.completed ?? task.completed;
  res.json(task);
});

// DELETE a task
router.delete('/:id', (req, res) => {
  tasks = tasks.filter(t => t.id !== parseInt(req.params.id));
  res.status(204).end();
});

module.exports = router;

3. Link Routes to the Server:

Now, update your index.js to use these routes:

const taskRoutes = require('./routes/tasks');

app.use('/api/tasks', taskRoutes);

Instead of using an in-memory array, you’ll typically store your data in a database like MongoDB.

1. Create a Mongoose Model:

Start by defining a Mongoose model for tasks. Create a models directory and a Task.js file inside it:

mkdir src/models
touch src/models/Task.js

In Task.js, define the schema and model:

const mongoose = require('mongoose');

const TaskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  completed: {
    type: Boolean,
    default: false
  }
});

const Task = mongoose.model('Task', TaskSchema);

module.exports = Task;

2. Update the Routes to Use the Database:

Modify the tasks.js routes to interact with the MongoDB database using the Mongoose model:

const Task = require('../models/Task');

// GET all tasks
router.get('/', async (req, res) => {
  try {
    const tasks = await Task.find();
    res.json(tasks);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// GET a single task by ID
router.get('/:id', async (req, res) => {
  try {
    const task = await Task.findById(req.params.id);
    if (!task) return res.status(404).json({ message: 'Task not found' });
    res.json(task);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// POST a new task
router.post('/', async (req, res) => {
  const task = new Task({
    title: req.body.title
  });
  try {
    const newTask = await task.save();
    res.status(201).json(newTask);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

// PUT update a task
router.put('/:id', async (req, res) => {
  try {
    const task = await Task.findById(req.params.id);
    if (!task) return res.status(404).json({ message: 'Task not found' });

    task.title = req.body.title || task.title;
    task.completed = req.body.completed ?? task.completed;
    await task.save();
    res.json(task);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

// DELETE a task
router.delete('/:id', async (req, res) => {
  try {
    const task = await Task.findById(req.params.id);
    if (!task) return res.status(404).json({ message: 'Task not found' });

    await task.remove();
    res.status(204).end();
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

3. Test Your API:

Use tools like Postman or curl to test your API endpoints by sending requests to http://localhost:5000/api/tasks.

Developing the backend with Node.js involves setting up an Express server, designing API endpoints, and connecting to a database to handle CRUD operations. By following these steps, you can build a solid backend that efficiently manages data and serves as a strong foundation for your web application.