HomeEducationUtilizing ultrafetch to spice up node-fetch habits - LogRocket Weblog Receive US

Utilizing ultrafetch to spice up node-fetch habits – LogRocket Weblog Receive US

In 2015, JavaScript launched the Fetch API, which is predicated on the fetch() perform. This new technique of managing native and distant assets was shortly adopted by browsers, however Node.js took for much longer. In reality, fetch() was solely added to the usual library in 2022.

Whereas the Fetch API shortly turned a preferred selection for making HTTP requests in Node apps, its implementation remains to be a step behind present requirements. It has some limitations and disadvantages that hinder its potential, and it’s more likely to take the core group years to handle all of them.

The answer to those shortcomings is named ultrafetch, a light-weight library that goals to raise the capabilities of fetch by modular utilities. Its objective is to resolve the issues of Node’s Fetch API implementation and assist enhance the developer expertise because of this.

On this article, we’ll cowl:

A short overview of the Fetch API in Node.js

The JavaScript Fetch API offers an interface primarily based on the fetch() perform for fetching native or distant assets. It was launched as a versatile substitute for XMLHttpRequest and has been supported by hottest browsers since 2015.

Node, nevertheless, took for much longer to embrace it. Throughout this time, the node-fetch library turned probably the most common non-official implementations of the Fetch API for Node.js.

In April 2022, Node lastly added experimental assist for fetch() in v17.5. Its implementation is predicated on Undici, a quick, dependable, and spec-compliant HTTP/1.1 shopper for Node.js.

As of Node v18, fetch() is a part of the usual Node API and can be utilized with out manually importing it or putting in any further library.

Understanding a recognized disadvantage of fetch

fetch has shortly develop into probably the most common purchasers for making HTTP requests in Node functions. Some elements behind its success embody:

  • Native integration with Node
  • Backed by a quick implementation
  • Straightforward to make use of

Nonetheless, there’s nonetheless rather a lot to do to make it totally compliant with HTTP RFC requirements. It’s going to most likely take one other yr or two earlier than we see the Fetch API totally stabilized in Node.

A serious disadvantage of the present implementation of fetch is its lack of a built-in, standards-compliant caching system. Caching is essential for enhancing efficiency and lowering redundant requests to the identical endpoint, particularly when coping with often requested information.

On the time of this writing, the one strategy to cache fetch responses is to retailer them in reminiscence or on disk, counting on customized logic or exterior caching libraries. This provides complexity to the code and may result in inconsistent implementations.

Fortunately, there’s a resolution to this downside referred to as ultrafetch!

What’s ultrafetch?

ultrafetch is a Node.js library that gives modular utilities for enhancing the usual fetch and npm node-fetch libraries. It may possibly additionally prolong any library that follows the Carry Your Personal Fetch (BYOF) strategy, corresponding to @vercel/fetch.

The primary objective behind ultrafetch is to boost the Fetch API with an RFC-7234-compliant caching system. The library makes use of an in-memory Map occasion because the default cache engine for storing Response objects produced by the Fetch API’s GET, POST, or PATCH requests. Customized caches are supported as nicely.

To know how this library works, contemplate the next instance.

Suppose that your Node backend must make an HTTP GET request to get some information as a part of the enterprise logic of an API endpoint. Every API name to that endpoint would require a brand new HTTP GET request.

If this request all the time returns the identical information, you could possibly cache the response the primary time after which learn it from reminiscence the next occasions. That’s precisely what ultrafetch is all about!

That’s nice, however ultrafetch additionally comes with some downsides to handle. First, though it’s referred to as “Extremely Fetch,” it provides solely a single important characteristic to fetch. Second, it isn’t actively maintained.

Even so, utilizing this library does assist improve fetch habits. In the remainder of this tutorial, we’ll discover how and see ultrafetch in motion with a sensible instance.

The right way to add caching to fetch with ultrafetch

Now, let’s discover ways to combine ultrafetch into Node.js in a step-by-step tutorial. To observe alongside, you want a Node.js 18+ venture.

The code snippets under might be in TypeScript, so I like to recommend testing our tutorial to discover ways to arrange a Node.js Specific app in TypeScript. Nonetheless, you possibly can simply adapt the code snippets to JavaScript, so a Node.js Specific venture in JavaScript will work as nicely.

Putting in ultrafetch and node-fetch

Add ultrafetch to your venture’s dependencies with the next command:

npm set up ultrafetch

As a TypeScript library, ultrafetch already comes with typings. This implies you don’t want so as to add any @varieties library.

Moreover, as talked about earlier than, fetch is already a part of Node.js 18, so there’s no want to put in it. For those who as an alternative choose to make use of node-fetch, set up it with:

npm set up node-fetch

Nice! You’re prepared to spice up any fetch implementation!

Extending fetch with ultrafetch

All you need to do to increase a fetch implementation with ultrafetch is to wrap it with the withCache() perform:

// import fetch from "node-fetch" -> if you're a node-fetch person
import  withCache  from "ultrafetch"

// prolong the default fetch implementation
const enhancedFetch = withCache(fetch)

withCache() enhances fetch by including caching performance.

Then, you need to use the enhancedFetch() perform similar to fetch():

const response = await enhancedFetch("

The request URL used above comes from the PokéAPI venture, a group of free API endpoints that return Pokémon-related information.

This can print:

  // omitted for brevity...
  identify: 'pikachu',
  order: 35,
  past_types: [],
    identify: 'pikachu',
    url: '
  // omitted for brevity...
  varieties: [  slot: 1, type: [Object]  ],
  weight: 60

As you possibly can see, it really works similar to the usual Fetch API. The advantages of ultrafetch present up when making the identical request twice.

After the primary request, the response object might be added to the inner in-memory Map cache. When repeating the request, the response might be extracted from the cache and returned instantly without having for community turnaround, which saves time and assets.

You possibly can import and use isCached() from ultrafetch to confirm this habits:

import  withCache, isCached  from "ultrafetch"

This perform returns true when the given response object was returned from the cache. In any other case, it returns false.

Check it in an instance just like the under:

const response1 = await enhancedFetch("
console.log(isCached(response1)) // false

const response2 = await enhancedFetch("
console.log(isCached(response2)) // true

Observe that the primary request is carried out, whereas the response for the second is learn from the cache as anticipated.

Including a customized cache

The default caching characteristic launched by ultrafetch is nice, but additionally restricted in that it doesn’t permit you to entry and management the inner cache.

There’s no strategy to programmatically clear the cache or take away a selected merchandise from it. As soon as a request is made, it will likely be cached eternally, which will not be the specified habits.

For that reason, withCache additionally accepts a customized cache object:

class MyCustomCache extends Map<string, string> 
    // overwrite some strategies with customized logic...

const fetchCache: MyCustomCache = new MyCustomCache()

const enhancedFetch = withCache(fetch,  cache: fetchCache )

This mechanism offers you management over the cache object. For instance, now you can clear the cache with the next command:


The cache parameter should be of sort Map<string, string> or AsyncMap<string, string>. You should utilize both a Map occasion or instantiate an object of a customized sort extending one among two interfaces, as accomplished above. The latter strategy is extra versatile if you wish to write some customized caching logic.

AsyncMap is a customized ultrafetch sort that represents a regular Map the place every technique is async:

export interface AsyncMap<Okay, V> 
    clear(): Promise<void>;
    delete(key: Okay): Promise<boolean>;
    get(key: Okay): Promise<V 

That is helpful when your cache storage must carry out asynchronous operations.

Seeing ultrafetch in motion

Time to place all of it collectively and see ultrafetch in motion in a whole instance:

// import fetch from "node-fetch" -> if you're a node-fetch person
import  withCache, isCached  from "ultrafetch"

// outline a customized cache
class MyCustomCache extends Map<string, string> 
    // overwrite some strategies with customized logic...

const fetchCache: MyCustomCache = new MyCustomCache()

// prolong the fetch implementation
const enhancedFetch = withCache(fetch,  cache: fetchCache )

async perform testUltraFetch() 
    const response1 = await enhancedFetch("
    console.timeEnd("request-1") // ~ 300ms
    const isResponse1Cached = isCached(response1)
    console.log(`request-1 cached: $isResponse1Cachedn`) // false

    const response2 = await enhancedFetch("
    console.timeEnd("request-2") // ~ 30ms
    const isResponse2Cached = isCached(response2)
    console.log(`request-2 cached: $isResponse2Cachedn`)  // true

    // clear the cache utilized by the boosted fetch

    const response3 = await enhancedFetch("
    console.timeEnd("request-3") // ~300ms (could also be a decrease due to server-side caching from PokéAPI)
    const isResponse3Cached = isCached(response3)
    console.log(`request-3 cached: $isResponse3Cachedn`)  // false


Run the Node script and it’s best to get one thing like this:

request-1: 234.871ms
request-1 cached: false

request-2: 21.473ms
request-2 cached: true

request-3: 109.328ms
request-3 cached: false

Apart from isCached(), you possibly can show that ultrafetch is studying the request-2 response from the cache by trying on the request occasions. After clearing the cache, request-3 ought to behave similar to request-1.

Observe that request-3 takes much less time than request-1 as a result of the Pokémon API implements server-side caching. After the primary chilly request, it already has the response prepared and may return it sooner.

For those who examine fetchCache after request-1, you’re going to get:

As you possibly can see, ultrafetch makes use of the HTTP technique and URL of the request as the important thing of the cache entries within the following format:


Now, substitute the GET calls with some POST requests:

const response1 = await enhancedFetch(" 
    technique: "POST",
    physique: `
      pokemon: pokemon_v2_pokemon(the place: identify: _eq: "pikachu") 

On this case, fetchCache will include the next array:

Result Of Replacing Get Calls With Post Requests Showing Fetchcache With Array Accounting For Headers And Body Of Request

This proves that ultrafetch doesn’t cache responses primarily based solely on the vacation spot API endpoint. As an alternative, it additionally takes under consideration the headers and physique of the request.

Particularly, it hashes fetch‘s header and physique objects and concatenates the ensuing strings to the <HTTP_METHOD>:<request_url> key string.

Congrats! You simply discovered easy methods to enhance fetch with ultrafetch!


On this article, you discovered what the JavaScript Fetch API is, why its implementation in Node.js has some shortcomings, and easy methods to sort out them with ultrafetch.

Whereas this library extends fetch with helpful performance, utilizing libraries to boost fetch just isn’t one thing new. For instance, the fetch-retry library provides retry logic to fetch to routinely repeat requests in case of failures or community issues.

As seen right here, ultrafetch is an npm library that provides caching capabilities to the fetch and node-fetch modules. It addresses one of many main drawbacks of each implementations of the Fetch API, as they don’t present a standardized-based strategy to cache server responses.

With ultrafetch, you possibly can simply cache HTTP responses produced by any fetch-compliant implementation, saving time and avoiding losing assets on pointless requests.

200’s solely Utilizing ultrafetch to spice up node-fetch habits - LogRocket Weblog Receive US Obtain US Monitor failed and gradual community requests in manufacturing

Deploying a Node-based internet app or web site is the straightforward half. Ensuring your Node occasion continues to serve assets to your app is the place issues get more durable. For those who’re thinking about making certain requests to the backend or third get together companies are profitable, try LogRocket.

LogRocket is sort of a DVR for internet and cell apps, recording actually all the pieces that occurs whereas a person interacts together with your app. As an alternative of guessing why issues occur, you possibly can combination and report on problematic community requests to shortly perceive the foundation trigger.

LogRocket devices your app to file baseline efficiency timings corresponding to web page load time, time to first byte, gradual community requests, and in addition logs Redux, NgRx, and Vuex actions/state. Start monitoring for free.

#ultrafetch #enhance #nodefetch #habits #LogRocket #Weblog

Continue to the category


Please enter your comment!
Please enter your name here

- Advertisment -spot_img

Most Popular

Recent Comments