Introduction to REST APIs with Node.js

  In today's web and mobile application development landscape, APIs (Application Programming Interfaces) are the fundamental pillar that allows communication between different systems.

  One of the most popular architectures for designing APIs is REST (Representational State Transfer).

  Combining REST with Node.js, a server-side JavaScript runtime environment, and the Express.js framework, gives you a powerful combination to build robust and scalable APIs efficiently.

What is a REST API?

  A RESTful API (or simply REST API) is a set of architectural principles for designing web services. It is not a protocol, but an architectural style that uses the HTTP protocol to communicate between systems.

  The central idea of REST is to treat everything as aresource, which is identified by a unique URI (Uniform Resource Identifier).

Key REST principles include:

• Client-Server Architecture: The client and server are separated and can evolve independently.
• Stateless: Each client request to the server must contain all the information needed for the server to understand and process it. The server does not store any client session state between requests.
• Cacheable: Responses can be cached to improve performance.
• Uniform Interface: REST APIs must have a standard way of interacting with resources, using HTTP methods and predictable URLs.
• Layered System: A client can connect to an intermediary (such as a proxy or load balancer) without knowing it.

HTTP Methods in REST (CRUD Operations)

REST APIs use standard HTTP methods to perform operations on resources. These methods are commonly mapped to CRUD (Create, Read, Update, Delete) operations:

• POST: Used to create a new resource.
  Example: POST /products (creates a new product).
• GET: Used to read (retrieve) one or more resources.
  Example: GET /products (gets all products), GET /products/123 (gets the product with ID 123).
• PUT: Used to completely update an existing resource or create one if it doesn't exist (idempotent).
  Example: PUT /products/123 (updates the product with ID 123).
• PATCH: Used to partially update an existing resource.
  Example: PATCH /products/123 (updates only some fields of product 123).
• DELETE: Used to delete a resource.
  Example: DELETE /products/123 (deletes the product with ID 123).

REST APIs commonly exchange data in JSON (JavaScript Object Notation) format due to its readability and ease of parsing.

Building REST APIs with Node.js and Express.js

Node.js is an ideal runtime environment for building APIs due to its asynchronous and event-driven nature, which makes it very efficient for handling a large number of concurrent connections.Express.js is a minimalist and flexible web framework for Node.js that greatly simplifies the creation of RESTful APIs.

Getting Started with Express.js:

1. Initialize a Node.js project:

mkdir my-rest-api
cd my-rest-api
npm init -y

2. Install Express.js:

npm install express

3. Create a basic API file (e.g., app.js):

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

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

// Example data (simulating a database)
let products = [
  { id: 1, name: 'Laptop', price: 1200 },
  { id: 2, name: 'Mouse', price: 25 },
];

// GET route to get all products
app.get('/api/products', (req, res) => {
  res.json(products);
});

// GET route to get a product by ID
app.get('/api/products/:id', (req, res) => {
  const productId = parseInt(req.params.id);
  const product = products.find(p => p.id === productId);
  if (product) {
    res.json(product);
  } else {
    res.status(404).send('Product not found.');
  }
});

// POST route to create a new product
app.post('/api/products', (req, res) => {
  const newProduct = {
    id: products.length > 0 ? Math.max(...products.map(p => p.id)) + 1 : 1,
    name: req.body.name,
    price: req.body.price,
  };
  products.push(newProduct);
  res.status(201).json(newProduct); // 201 Created
});

// PUT route to update an existing product
app.put('/api/products/:id', (req, res) => {
  const productId = parseInt(req.params.id);
  const productIndex = products.findIndex(p => p.id === productId);

  if (productIndex !== -1) {
    products[productIndex] = {
      ...products[productIndex],
      name: req.body.name,
      price: req.body.price,
    };
    res.json(products[productIndex]);
  } else {
    res.status(404).send('Product not found.');
  }
});

// DELETE route to delete a product
app.delete('/api/products/:id', (req, res) => {
  const productId = parseInt(req.params.id);
  const initialLength = products.length;
  products = products.filter(p => p.id !== productId);

  if (products.length < initialLength) {
    res.status(204).send(); // 204 No Content (successfully deleted)
  } else {
    res.status(404).send('Product not found.');
  }
});

// Start the server
app.listen(PORT, () => {
  console.log(`REST API server listening on http://localhost:${PORT}`);
});

4. Run the application:

node app.js

  This basic example illustrates how Express.js allows you to define routes and handle different HTTP methods to interact with your resources. By mastering these concepts, you'll be well-equipped to build complete and functional RESTful APIs with Node.js.