Building Your First Express Server

1. Defining the Application (src/app.js)

First, we'll create a file dedicated to defining the Express application and its middleware.

Action: Create the Application File

1. In your src/ directory, create a new file named app.js.
2. Add the following code to src/app.js:

const express = require('express');

// Create the Express app instance
const app = express();

// Middleware to parse JSON request bodies
app.use(express.json());

// A simple route for the root to confirm the server is running
app.get('/', (req, res) => {
  res.status(200).json({ message: 'API is running' });
});

module.exports = app;

What is express.json()?

The line app.use(express.json()); is a crucial piece of middleware. A REST API communicates using JSON. When a client sends a POST or PUT request with a JSON payload in its body, this middleware parses that raw JSON text into a JavaScript object and attaches it to the request object at req.body. Without it, req.body would be undefined, and you wouldn't be able to access any data sent by the client.

To hear this explained, the following short clip is very direct.

2. Starting the Server (server.js)

Now, we'll create a separate file whose only job is to start the server. This file will import the app we just defined and tell it to start listening for requests.

Action: Create the Server File

1. In your project's root directory (the same level as package.json), create a new file named server.js.
2. Add the following code to server.js:

// This must be the first line to ensure environment variables are loaded
require('dotenv').config();

const app = require('./src/app');

// Use the PORT from .env, or 5000 as a default
const PORT = process.env.PORT || 5000;

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

The app.js / server.js Pattern

You now have two files managing the server:

• src/app.js: Defines the Express application, its middleware, and its routes. It exports the app object.
• server.js: Imports the app object, reads the port from the environment, and starts the server.

This separation is a production-ready pattern. It allows you to import app.js in your test files without actually starting the server, giving you full control during testing. The following resource shows this exact structure.

3. Running and Verifying Your Server

Let's bring your server to life.

Step 1: Update your .env file

Ensure your .env file in the root directory contains the port definition:

PORT=5000

Step 2: Add a Start Script

In your package.json file, add a start script. This is the standard command for running a Node.js application.

"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "start": "node server.js"
},

Step 3: Run the Server

Open your terminal in the project's root directory and run the script:

npm start

You should see the confirmation message in your console:

Server is running on port 5000

Your server is now running! You can open a web browser and navigate to http://localhost:5000. You should see the JSON response: {"message":"API is running"}.

To stop the server, go back to your terminal and press Ctrl+C.

Conclusion

Congratulations, you have a running Node.js and Express server! You've successfully completed the entire project setup module.

Key Takeaways:

• The Express application is created by calling const app = express().
• The app.use(express.json()) middleware is mandatory for parsing JSON request bodies in a REST API.
• Separating your application logic (app.js) from your server startup (server.js) is a professional standard that enables easier testing.
• The server is started with app.listen(), using process.env.PORT to allow for flexible deployment configurations.
• npm start is the conventional command to run your application.

With the server foundation now solidly in place, we can move on to the next critical component. In the next module, you'll connect this application to a MongoDB database using Mongoose, define a data schema, and create a model. This will prepare you to build the core CRUD (Create, Read, Update, Delete) functionality of your API.