Dependency injection in Express - Step-by-Step Execution

Concept Flow - Dependency injection in Express

Create dependencies

↓

Inject dependencies into middleware or routes

↓

Express app uses injected dependencies

↓

Handle requests using injected services

↓

Send response

This flow shows how dependencies are created, injected into Express routes or middleware, and then used to handle requests.

Execution Sample

Express

const express = require('express');
const app = express();

const logger = { log: msg => console.log('LOG:', msg) };

app.get('/', (req, res) => {
  logger.log('Home route accessed');
  res.send('Hello');
});

This code creates a logger dependency and injects it into the route handler to log messages when the route is accessed.

Execution Table

Step	Action	Dependency State	Effect
1	Create logger object	logger = { log: function }	Logger ready to use
2	Define route '/' with injected logger	logger available in route	Route can call logger.log
3	Request to '/' received	logger unchanged	Route handler runs
4	Call logger.log('Home route accessed')	logger logs message	Console shows: LOG: Home route accessed
5	Send response 'Hello'	logger unchanged	Client receives 'Hello'
6	Request handled fully	No changes	Waiting for next request

💡 Request completes after response is sent, dependency remains ready for next use

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
logger	undefined	{ log: function }	{ log: function }	{ log: function }	{ log: function }
req	undefined	undefined	{ request object }	{ request object }	undefined
res	undefined	undefined	{ response object }	{ response object }	undefined

Key Moments - 3 Insights

Why does the logger object stay the same throughout the request?

Because the logger is created once and injected as a shared dependency; it is not recreated per request (see execution_table steps 1 and 3).

How does the route handler access the logger dependency?

The logger is available in the route's scope because it was defined outside and used inside the route callback (execution_table step 2).

What happens if we modify the logger inside a request?

Modifying the logger would affect all future requests since it's shared; typically, dependencies are kept stateless or carefully managed (not shown in this example).

Visual Quiz - 3 Questions

Look at the execution table, what is the state of 'logger' after step 3?

A Undefined

B An object with a log function

C A string message

D Null

💡 Hint

Check the 'Dependency State' column at step 3 in the execution_table

At which step does the console output 'LOG: Home route accessed' appear?

A Step 5

B Step 2

C Step 4

D Step 6

💡 Hint

Look at the 'Effect' column describing console output in the execution_table

If the logger was recreated inside the route handler, how would the variable tracker change?

A Logger would have different instances after each request

B Logger would be null after step 3

C Logger would be undefined at start and after step 1

D Logger would not appear in variable tracker

💡 Hint

Consider how variable values change when a new object is created per request, referencing variable_tracker

Concept Snapshot

Dependency injection in Express:
- Create dependencies (e.g., services, loggers) outside routes
- Inject them by referencing in route handlers or middleware
- Allows easy reuse and testing
- Keeps code clean and modular
- Dependencies stay consistent across requests unless recreated

Full Transcript

Dependency injection in Express means creating reusable objects like loggers or services outside route handlers and then using them inside routes. This way, the same dependency is shared and used whenever a request comes in. The flow starts by creating dependencies, then injecting them into routes, handling requests using these dependencies, and finally sending responses. The example shows a logger object created once and used inside a route to log messages when the route is accessed. The logger remains the same across requests, ensuring consistent behavior. This approach helps keep code organized and easy to test.