JavaScript REST APIs: 4 Critical Methods

Organizations use JavaScript to create dynamic and interactive web pages across various browsers. With growing demand and many new emerging frameworks, JavaScript assists programmers in developing large-scale web applications.

Today, most modern web applications leverage REST architecture to enhance the dynamic capabilities of the website. This growing demand for interaction with REST API using JavaScript has surged the development of new libraries that allows developers to make HTTP requests effectively.

Prerequisites

• An idea of HTTP requests.
• Understanding of API calls.

Introduction to REST API

Unlike APIs that enable the connection between computers or computer programs, REST API strictly adheres to REST architecture. With REST APIs, developers experience higher flexibility and lightweight technique to integrate applications that allow access to web services without the need for massive processing capabilities.

Principle of REST API

Here are a few key principles of REST APIs, that can help you understand their value better:

1. Statelessness

Statelessness enforces servers to remain unaware of the clients’ state. The server would not store anything about HTTP requests made by the client or vice versa, thereby treating every query as new. REST API follows a set of constraints laid by the REST paradigm that is bound to become stateless.

2. Cacheable

Cache helps servers to attenuate a few constraints of statelessness. It is a critical factor that has improved the performance of modern web applications.

The goal is not only to improve performance on the client-side but also to scale them on the server-side. A well-established cache mechanism would drastically reduce the server’s average response time by avoiding submitting the same request twice.

3. Decoupled

REST is a distributed approach where client and server applications completely decouple (independent) each other. Irrespective of where the requests are initiated, the only information the client application knows is the requested resource’s uniform resource identifier (URI).

A server application should pass requested data via HTTP but should not try modifying the client application.

4. Layered

With a layered system, REST architecture is scalable. As RESTful architecture has decoupled client and server applications, all the calls and responses of REST APIs go through different layers.

In a layered system, neither client nor the server identifies the source or an intermediary of communication. 

5. Uniform Interface

REST API follows the principles that define a uniform interface and prohibits using self or multiple interfaces within an API. It should also ensure that similar data belongs to only one uniform resource identifier (URI). Preferably, all API requests for the same resources should look alike, irrespective of the initial request.

Understanding CRUD and Endpoints

CRUD is an acronym for Create, Read, Update, and Delete commands to interact with databases. Unlike REST, which is an architectural system, CRUD operations are cyclic.

Despite its origin from databases, it maps the design principle of dynamic applications like HTTP, SQL, and DDS. For any dynamic website, there exist multiple CRUD cycles. Below are terms that define CRUD operation:

1. Create: This is a procedure that generates new records through an ‘INSERT’ statement.
2. Read: This is a procedure used to read/retrieve data based on desired input parameters.
3. Update: This is a procedure used to modify records without overwriting them.
4. Delete: This is a procedure used to remove one or more entries entirely.

API functions use ‘requests’ and ‘responses’ to authenticate and transfer information. When an API requests information from a web application or web server, it will receive a ‘response.’ The place that APIs send requests or where resources live are called endpoints.

An endpoint is a specific address that gives you certain features. In simple terms, it is one end of a communication channel. Each endpoint is a location where APIs can access the resources needed to carry out various operations.

Methods to interact with JavaScript REST API

JavaScript provides several ways to send ‘requests’ and get ‘responses.’ There are some native as well as many third-party libraries that help you send HTTP requests or parse a JSON response. Below are a few libraries that have eased to request and dynamic loading of content:

1. XMLHttpRequest
2. Fetch
3. Axios
4. SuperAgent

1. XMLHttpRequest

XMLHttpRequest (XHR) is a built-in API in JavaScript that encapsulates the logic of sending HTTP requests without refreshing a loaded web page. Modern web browsers have built-in XHR objects to request data from the server. XHR object can:

• Update a web page without reloading a page.
• Request data from a server even after a page has loaded.
• Receive data from a server even after the page has loaded.
• Send data to a server running in the background.

Though XHR is the building block of many popular HTTP request modules, developers rarely use this REST API JavaScript. Sending a ‘GET’ request involves three steps — creating XMLHttpRequest, opening the HTTP request, and sending the request. Use the below code to use the XHR object:

Once the request is sent, you can use the event handlers to handle XHR object responses. Below are a few examples where an event handler is called:

• On-Load
• On-Progress

• On-Error

2. Fetch

Fetch is a simple native JavaScript REST API used to make HTTP requests to servers and load web page information. As the ‘Fetch’ library caters to modern applications, it has become one of the most popular JavaScript ways to send HTTP requests.

This method takes two inputs: URL and array of properties (optional). Fetch also reduces the complexity and verboseness of the code with the use of simpler syntax and promises. To check whether the response contains an HTTP error, you can also use the ‘response.ok’ field as shown below:

3. Axios

Axios is one of the most popular third-party packages used for making HTTP requests in JavaScript. It is a promise-based HTTP client that can be used with JavaScript and advanced frameworks like React, Vue.js, and Angular.

While the server-side uses the native node.js HTTP module, the client-side use XHR. Compared to Fetch, Axios significantly reduces the amount of work on users’ end to make HTTP requests.

It automatically parses the received JSON data, which you can access through response.data field. Below is the code to create a ‘GET’ request from Axios:

4. SuperAgent

SuperAgent is a third-party package introduced to JavaScript for making high-level client HTTP requests. Although similar to Axios,

it is a mature and well-supported module in JavaScript. SuperAgent uses XHR JavaScript REST API and comes with a broad set of features useful in handling several request tasks.

This package supports both promise-based and callback-based implementations. To send ‘GET’ requests using SuperAgent, use the below code:

Steps to interact with JavaScript REST API

Below steps will guide you to interact

• Step 1: If the task involves a ‘request’ to the JavaScript REST API without using any external (third-party) JavaScript library, you can use an XHR object. Use the below code:

It may involve four basic steps:

• Initialize the XMLHttpRequest because the XHR object holds the data for HTTP requests and sends it to the desired JavaScript REST API.
• Open the request by passing a method and a URL, where a ‘method’ may usually involve a CRUD operation. For instance, a ‘GET’ method is used to retrieve data from a JavaScript REST API. 
• Send a request to the server. As XHR is asynchronous (default), it doesn’t block your application until a response is received. 
• The final step to interact with a JavaScript REST API is to handle events while receiving and dealing with a response, this functions whenever a response arrives.

• Step 2: Suppose the task is to add movies in the desired database, you can use the ‘FormData,’ object and append its fields. To add data, you can use the ‘POST’ method in the XHR object along with the URL and send it to FormData. Use the below code to accomplish this task:

If you want to send the string containing the JSON object along with a header telling the JavaScript REST API that data is in JSON format, use the below code:

• Step 3: As the new versions of JavaScript garner rich libraries, developers prefer using the ‘fetch()’ function. To retrieve data using ‘Fetch’ instead of XHR, use the below code:

If you are unsure whether a browser will support a ‘fetch’ object, use the ‘.then()’ function to inform JavaScript what should be done when a response arrives. This object keeps the code cleaner and also deals with responsive handling.

Conclusion

• JavaScript has gained wide applications to create a rich server interface with simplicity, popularity, and high-speed operation.
• As there is global support to the developer community, many big organizations like Google created Angular framework, and Facebook created React.js framework to consume REST APIs.
• The interaction of JavaScript REST APIs has enhanced the ability to support all modern browsers and produce an equivalent result.