Dependency Injection for Handlers

In this lesson, you will learn how to decouple your route handlers from specific implementations by injecting dependencies, allowing you to swap real services for mocks during testing.

The Problem: Hard-Coded Dependencies

When you build a server, your route handlers often need to talk to a database or an external API. A common mistake is to import the database module directly inside the handler file:

// userHandler.js
const db = require('./database'); // Direct dependency

async function getUser(req, res) {
  const user = await db.findUser(req.params.id);
  res.end(JSON.stringify(user));
}

This approach makes unit testing difficult. If you want to test getUser, you are forced to connect to a real database. You cannot easily "fake" the database result because the handler is tightly coupled to the ./database module.

The Solution: Dependency Injection

Dependency Injection (DI) flips this relationship. Instead of the handler reaching out to fetch its dependencies, you provide (or inject) them when you define the route. You can write your handler as a function that accepts its dependencies as arguments:

// userHandler.js - Dependency Injection style
function getUserHandler(dbService) {
  return async (req, res) => {
    const user = await dbService.findUser(req.params.id);
    res.end(JSON.stringify(user));
  };
}

Now, in your main server file, you pass the real database service into the handler when setting up your routes:

// server.js
const db = require('./database');
const { getUserHandler } = require('./userHandler');

// Inject the real dependency here
router.get('/users/:id', getUserHandler(db));

Why This Matters

By structuring your code this way, your unit tests become trivial. In a test file, you can simply pass a "mock" object that looks like the database but returns dummy data instantly. You don't need a network connection or a running database instance to verify that your route handler correctly processes the response. This pattern keeps your business logic isolated from your infrastructure, leading to a more robust and maintainable codebase.

Key Takeaway: By passing dependencies into your handlers rather than importing them directly, you transform your code into a testable, modular system where external services can be swapped out with ease.