Rapid REST API Prototyping with JSON Server and Node.js

Learn how to quickly create mock REST APIs using JSON Server and Node.js. This tutorial shows you how to set up a JSON server, define routes, and perform CRUD operations, ideal for prototyping, testing, and development without complex backend setup.

Creating and Using a JSON Server with Node.js

Introduction to JSON Server

JSON Server is a lightweight Node.js module that quickly creates mock REST APIs from a JSON file. It's perfect for prototyping, testing, and development because it lets you simulate a backend server and API without the overhead of setting up a database or writing complex server-side code. It handles common HTTP requests (GET, POST, PUT, DELETE, PATCH).

Installation and Setup

1. Install json-server: Open your terminal and run: npm install -g json-server
2. Create a JSON database (db.json): Create a JSON file containing your sample data. For example:

{
  "posts": [
    { "id": 1, "title": "json-server", "author": "typicode" }
  ],
  "comments": [
    { "id": 1, "body": "some comment", "postId": 1 }
  ],
  "profile": { "name": "typicode" }
}

3. Start the server: Run this command in your terminal (in the same directory as `db.json`): json-server --watch db.json. This starts the server in watch mode, automatically updating the API if the `db.json` file changes. The default port is 3000.

Key Considerations for JSON Server Requests

• Modifying Data (POST, DELETE, PUT, PATCH): Changes made through these requests are saved directly to `db.json`.
• Request Body: For POST, PUT, and PATCH requests, the request body should be a valid JSON object.
• IDs: IDs are generally immutable. The ID in the request body is ignored for PUT and PATCH requests.
• Content-Type Header: For POST, PUT, and PATCH, include the header: Content-Type: application/json. Otherwise, updates may not be saved.

Defining Routes

JSON Server automatically creates routes based on your `db.json` file. You can customize routes using the --routes flag. Here are some examples:

Singular Routes (for single resources):

• GET /profile
• POST /profile
• PUT /profile
• PATCH /profile

Plural Routes (for collections of resources):

• GET /posts
• GET /posts/1
• POST /posts
• PUT /posts/1
• PATCH /posts/1
• DELETE /posts/1

Creating a REST API with JSON Server

A REST API is built by defining the data in `db.json`. CRUD (Create, Read, Update, Delete) operations are automatically available for each object in the JSON.

For example, a `db.json` file containing employee data:

{
  "employees": [
    {
      "id": 1,
      "first_name": "Sebastian",
      "last_name": "Eschweiler",
      "email": "sebastian@tutorialsarena.com"
    },
    // ... more employees ...
  ]
}

Starting the server (json-server --watch db.json) automatically creates REST endpoints for managing employees. You can then perform GET, POST, PUT, PATCH, and DELETE requests to interact with the data.

Additional JSON Server Features

• Static File Serving: Serve HTML, CSS, and JavaScript files by creating a `./public` directory or using the --static flag.
• Port Changes: Use the --port flag (e.g., --port 3004) to specify a different port.
• Middleware: Integrate custom middleware (e.g., for authentication or validation) using Express.js.

Using an In-Memory Database with JSON Server

For situations where you don't want to use a file (like `db.json`) to store your data, you can use an in-memory database with JSON Server. This is particularly useful when dealing with testing or prototyping where persistence isn't required. This is accomplished by passing a Javascript object directly to the `jsonServer.router()` function.

const jsonServer = require('json-server');
const server = jsonServer.create();
const path = require('path'); //Import the path module
const router = jsonServer.router(path.join(__dirname, 'db.json')); // Use an existing db.json file
//const router = jsonServer.router({employees: [{id:1, first_name: 'Test', last_name: 'User', email:'test@example.com'}]}); // Example in-memory data
const middlewares = jsonServer.defaults();
server.use(middlewares);
server.use(router);
server.listen(3000, () => {
  console.log('JSON Server is running');
});

In this example, the data is stored in memory and not persisted to a file. Remember to replace the example data with your own in-memory object.

Data Mocking with Faker.js

Manually creating large datasets for testing can be tedious. Faker.js is a library that generates realistic fake data, which is very helpful when working with JSON Server. This allows you to quickly create extensive datasets for testing and prototyping purposes. Here's how to use Faker.js with JSON Server:

1. Initialize project: Run npm init in your terminal.
2. Install Faker.js: Run npm install faker.
3. Create a data generation script (employees.js):

var faker = require('faker');

function generateEmployees() {
  var employees = [];
  for (var id = 0; id < 50; id++) {
    var firstName = faker.name.firstName();
    var lastName = faker.name.lastName();
    var email = faker.internet.email();
    employees.push({
      "id": id,
      "first_name": firstName,
      "last_name": lastName,
      "email": email
    });
  }
  return { "employees": employees };
}

module.exports = generateEmployees;

4. Start the server with Faker.js data: Run json-server employees.js. This will use the data generated by `employees.js`.

Summary of JSON Server Usage

This tutorial covered setting up a JSON server, creating and managing REST API endpoints, working with routes, and using Faker.js for data generation. JSON Server is a powerful tool for rapid prototyping and testing, simplifying the process of creating and managing mock APIs. Its ease of use and flexibility make it a popular choice for developers working with JSON data.