With color formatting, alignment and borders.

Lightening web component (LWC) framework is helping JavaScript developers big time in creating good features and innovative user interfaces on Salesforce.

Recently, we had a requirement to make a feature to export an Excel document from LWC component. There were a few options through which I could even export a plain Excel document, but there was almost nothing, no support at all, for styling like colors, borders, alignment, wrap, border colors, etc.

This got me thinking how could technology fail in such a common arena, so I did some internal research and came out with a solution.

Let’s move further to discuss the solution at length-

Integrating JavaScript Library with LWC

In precise words, I decided to use a JavaScript library write-excel-file, which is available on npm. I integrated this library on Lightening Web Components and found out that it was throwing exception due to locker service.

Let’s build an example based on Excel export-

Thereafter, I decided to customize the library write-excel-fileto make it compatible with LWC. You can download this version from here.

• First, download the write-excel-file.min.js-

• Now, make a folder writeExcel in static resources and put the downloaded file write-excel-file.min.js in it.

• Create lightening component excelJSDemo

Create a LWC with name excelJSDemo and add the following code to the excelJSDemo.js file.

import { LightningElement } from 'lwc';
import { loadScript } from "lightning/platformResourceLoader";
import workbook from "@salesforce/resourceUrl/excelDemo";
export default class ExcelJSDemo extends LightningElement {
    librariesLoaded = false;
    objectsData = [
        // Object #1
        {
            name: 'John Smith',
            dateOfBirth: new Date(),
            cost: 1800,
            paid: true
        },
        // Object #2
        {
            name: 'Alice Brown Alice Brown Alice Brown Alice Brown Alice Brown Alice Brown',
            dateOfBirth: new Date(),
            cost: 2600,
            paid: false
        }
    ]
    schemaObj = [
        // Column #1
        {
            column: 'Name',
            type: String,
            wrap: 'true',
            color: '#ccaaaa',
            value: student => student.name
        },
        // Column #2
        {
            column: 'Date of Birth',
            type: Date,
            format: 'mm/dd/yyyy',
            value: student => student.dateOfBirth
        },
        // Column #3
        {
            column: 'Cost',
            type: Number,
            format: '#,##0.00',
            value: student => student.cost
        },
        // Column #4
        {
            column: 'Paid',
            type: Boolean,
            value: student => student.paid
        }
    ]
    renderedCallback() {
        console.log("renderedCallback xlsx");
        if (this.librariesLoaded) return;
        this.librariesLoaded = true;
        loadScript(this, workbook + "/writeExcel/write-excel-file.min.js")
            .then(async (data) => {
                console.log("success------>>>", data);
            })
            .catch(error => {
                console.log("failure-------->>>>", error);
            });
    }
    // calling the download function from xlsxMain.js
    async download() {
        let _self = this;
        // When passing `objects` and `schema`.
        await writeXlsxFile(_self.objectsData, {
            schema: _self.schemaObj,
            fileName: 'file.xlsx'
        })
    }
}

• Update excelJSDemo.html to add a button to start download -

<template>
    <lightning-card title="Exceljs file export demo" icon-name="custom:custom14">
        <button onclick={download} class="btn success">Download</button>
    </lightning-card>
</template>

• Update excelJSDemo.js-meta.xml-

<?xml version="1.0" encoding="UTF-8"?>
<LightningComponentBundle xmlns="http://soap.sforce.com/2006/04/metadata" fqn="xlsxDemo">
    <apiVersion>46.0</apiVersion>
    <isExposed>true</isExposed>
    <targets>
        <target>lightning__AppPage</target>
        <target>lightning__RecordPage</target>
        <target>lightning__HomePage</target>
    </targets>
</LightningComponentBundle>

• Deploy and run your code

Now, you can deploy your code and drag this component to any layout you like. Once you add it to the layout, you will see a download button. I for one, added it as a tab to opportunity layout.

Once you click the download button, you will be able to download a beautiful Excel sheet with styles and formatting.

This library has many options for styling, check this link to learn more. Mainly, it supports the following styles-

• align: string - Horizontal alignment of cell content.

Available values: "left", "center", "right".

• alignVertical: string - Vertical alignment of cell content.

Available values: "top", "center", "bottom".

• height: number - Row height, in "points".
• span: number - Column span.

Even if a cell spans several columns, you still have to provide a value for every cell in every row and column.

• rowSpan: number - Row span.

Even if a cell spans several rows, you still have to provide a value for every cell in every row and column.

• wrap: boolean - Set to true to "wrap" text when it overflows the cell.
• fontWeight: string - Can be used to print text in bold.

Available values: "bold".

• color: string - Cell text color (in Hexadecimal format).

Example: "#aabbcc".

• backgroundColor: string - Cell background color (in Hexadecimal format).

Example: "#aabbcc".

• borderColor: string - Cell border color.

Example: "#aabbcc".

• borderStyle: string - Cell border style.

Example: "thick".

• leftBorderColor
• leftBorderStyle
• rightBorderColor
• rightBorderStyle
• topBorderColor
• topBorderStyle
• bottomBorderColor
• bottomBorderStyle

That was all, folks! Hope this article was useful for you. Share your queries in the comment box and hit claps 👏 if you liked the blog.

Tired of hearing ‘No’ from so-called Salesforce exports with LWC?

We, at Habilelabs, make every complex user interface with LWC ease and user friendly way. Contact us to discuss your LWC migration project with us.

Also Read-

• Promises in JavaScript- An Introductory Guide
• Google Flutter- From the Perspective of a React Native Developer

Salesforce: Export to Excel with Lightning Web Component was originally published in Minds Verse | HabileLabs on Medium, where people are continuing the conversation by highlighting and responding to this story.

Node.js 8 version released a new module called async_hooks. It provides an easy-to-use API to track the lifetime of async resources in Node.js applications.

It was introduced by the Node team in 2017 and is still in the experimental state.

The asynchronous resources mentioned here are the objects created by Node.JS that have associated callback and can be called multiple times. Some examples of asynchronous resources are Timeouts, Promises, TCPWRAP, Immediates, etc.

We’ll learn more about Async hooks and their use cases in this blog. Let’s get going then-

Why Do We Need Async Hooks?

Async resources are created by async process for example file read, database read operation, external API call. So naturally async resources keep track of callback which will be called once the process is completed. But, if we need to track the async resource like what is happening in the middle of an async resource execution, we don’t have any way to do that.

The typical lifecycle of such an async resource is similar to this:

To solve this concern, Nodejs provided async hooks to spy on the lifecycle of async resources.

Enough talking, show me the code!

Hello word to async hooks-

const fs = require('fs');
const { fd } = process.stdout;
const async_hooks = require('async_hooks')
function init(asyncId, type, triggerAsyncId, resource) {
    fs.writeSync(fd, `Init callback async id --> ${asyncId} \n`);
}
function destroy(asyncId) {
    fs.writeSync(fd, `Destroy callback async id -->${asyncId} \n`);
}
const asyncHook = async_hooks.createHook({ init: init, destroy: destroy });
asyncHook.enable();

setTimeout(()=>{
    //do nothing
}, 1000);

//output
/*
Init callback async id --> 4
Destroy callback async id -->4
*/

In the example above, we have setTimeout is making an async operation. We have created two async hooks init and destroy. When we execute the code, we can see that it is calling init first, and then callsdestroy function. You might be wondering why we are using fs.writeSync to print on console rather than using console.log.

Console.log is async function itself, so this will cause async hooks again, and will cause infinite recursion. So we can not use any async code inside async hooks. It will be discussed later on again in later in this article.

Async Hooks APIs

Essentially, the async hooks API provides these five key event functions that are called during different time and instances of the resource’s lifecycle, to track the async resources.

You have to specify the event that you want to trigger out of the following while creating an instance.

All the callbacks are optional. Let’s make this statement a little more obvious- It means if the cleanup data of the resource is to be tracked, then you only need to pass the destroy callback.

init

The init callback is called whenever a call is created that has the possibility of triggering an asynchronous event. Just for the record, at this point, we’ve already associated the hook with an async resource.

init callback receives these parameters when called-

• asyncId: Each async resource, when identified, is allotted with a unique ID.
• type: It depicts the type of the async resource in string form that triggered init callback.
• triggerAsyncId: asyncId of the resource for whose context the async resource was created. It shows why a specific resource was created.
• resource: It represents the reference to the async operation that is released during destroy.

All the other callbacks get only one parameter- asyncId.

Before

Whenever an async operation initiates or completes, a callback notifies the user of its status. The before callback is called right before this mentioned callback is executed, and the relevant resource will be assigned with a unique asyncId identifier.

The before callback can be called any times from 0 to n. For instance, when the asynchronous operation gets cancelled, it will be called 0 times, on the other hand, the persistent type resources can call it multiple times.

After

Similar to before, it is called post-execution of the relevant asynchronous resource or right after when the specified callback in before callback finishes its execution.

Destroy

It’s quite easy to guess, isn’t it? Yes, you guessed it right!

It is called every time the asynchronous resource, corresponding to the unique asyncId, is destroyed regardless of whatever happened to its callback function.

However, in some cases, the resource depend upon the garbage collection for its cleanup which might cause a memory leak in the application, which results in avoid calling destroy. If the resource does not rely upon the garbage, then it won’t be a problem and destroy will do the cleaning.

promiseResolve

This callback is triggered when the Promise gets its resolve function, which is invoked either directly or by some external means to resolve a promise.

Use Cases of Async Hooks

Listed below are some major features and use cases of async hooks-

- Promise Execution Tracking

Async hooks are preferably used to track the lifecycle of promises and their execution, as promises are also asynchronous resources.

Whenever a new promise is created, the init callback runs. The before and after hooks run pre- and post-completion of a PromiseReactionJob and the resolve hook is called when a promise is resolved.

Promises in JavaScript- An Introductory Guide

- Web Request Context Handling

This is another major use case of Async Hooks, where it stores relevant information in context to the request during its lifetime. This feature becomes highly useful to track the user’s behavior in a server.

With async hooks, you can easily store the context data and access it anywhere and anytime in the code.

The process starts with a new request to the server, which initiates calling createRequestContext function to get data to store in a Map. Every async operation initiated as part of this request will be saved in the Map along with the context data (Here init plays an important part).

Next, destroy keeps the size of the Map under control and do the cleaning. This is how you can get the current execution context by calling getContextData anytime.

- Error Handling with Async Hooks

Whenever an async hook callback throws an error, the application follows the stack trace and exits due to an uncaught exception. Unless you run the application with-abort-on-uncaught-exception, which will print the stack trace exiting the application, the exit callbacks will still be called.

This error handling behavior is due to the fact that all these callbacks run at potentially unstable points, for instance during construction or destruction of a class. This process prevents any unintentional and potential abort to the process by closing it quickly.

- Printing in Async Hooks

Printing is an asynchronous operation and console.log() triggers calling async callbacks. However, using such asynchronous operations inside async callbacks causes infinite recursion.

For instance, when init runs, the console.log() will trigger another init callback causing endless recursion and increasing stack size.

To avoid this, you should use a synchronous operation like fs.writeFileSync(file, msg, flag) while debugging as it will print to the file without invoking AsyncHooks recursively.

If the logging requires an asynchronous operation, you can track what caused the async operation to initiate using AsyncHooks. As it was logging itself that invoked the AsyncHooks callback, you can skip it which will break the infinite recursion cycle.

- Enhanced Stack Traces

The creator of Node.js, Ryan Dahl, talked about debugging problems in node.js due to event loops, which kills the stack trace. As the async hooks facilitate better tracing of async resources, it allows developers to improve and enrich the stack trace.

Bottom Line

Do you know that you can also measure the duration of an asynchronous operation in real-time? Yes you can, but by integrating Async hooks module with Performance API module.

Well, this was all about async hooks. I would suggest you to refer to the below link if you are interested to learn more about async hooks-ink-

Async hooks | Node.js v22.8.0 Documentation

If you liked this blog, don’t forget to hit the clap icon (multiple times 😉).

Looking to hire nodejs experts or outsource the project, connect with us here.

Originally published at https://www.habilelabs.io on September 09, 2021.

Read More-

• Data Fetching in Next.js — Pre-rendering Types
• Why Choose Nest.js over Other Node Frameworks?
• Hydra — A Node.js Microservice Library

Async Hooks in Node.js- Features & Use Cases was originally published in Minds Verse | HabileLabs on Medium, where people are continuing the conversation by highlighting and responding to this story.

I am currently working on a mobile app that allows schools and teachers to get connected with the students with their premium content, which only allows the registered students to watch the video content.

In this article, I’m going to share my experience about how did I set up cloud infrastructure for video on demand (VOD) using AWS and node.js.

What’s the Need For this Special Infrastructure??

For someone beginner, who does not have any experience with VOD might wonder why not just MP4? Why do we need a special infrastructure? You can just store the MP4 file and everyone can access and play it. This sounds just fine but limited to the only convention uses of a video, for instance where the video size is small, it will play fine with video players. But when the large video files are concerned, it becomes extremely difficult for a video player to play them as they need to be downloaded first and then played on.

Now imagine having two users, one of them having extremely good internet speed while another one with poor network speed. Now, when both users try to stream the same-quality video on their devices, there is no doubt that the first use will rather enjoy the video of wonderful speed but the other user will face video-buffering.
All these scenarios will lead to poor user experience. That’s why we need more reliable and practical methods to stream videos over the internet. There are various popular formats for video streaming.

Most Popular Video Format Options

To solve the above-mentioned problem, there are four popular video formats. Let’s see what are they and how can they offer more productive outputs-

1. HLS (HTTP live streaming): It is a media streaming protocol for delivering visual and audio media to viewers over the internet. It was first launched by Apple company back in 2009.

In this format, the whole video is broken into multiple small files of 10 seconds each and stored in a special format with .ts extension and there will be an m3u8 file that will work like the manifest file to keep track of these small files.

So, while we play the m3u8 file, it dynamically loads the chunks and video start playing as soon as the first chunk gets loaded in the player.

It uses an adaptive bit rate which helps video players decide based on network speed, what quality of the video to load.

I recommend this format as it is fully supported by all famous browsers, apple devices, android devices. Read more about HLS here

2. DASH (Dynamic Adaptive Streaming): It is the newest format, which has several advantages. However, I will not go into more detail. It is not yet supported on apple devices.

3. CMAF (Common Media Application Format): It was proposed by Apple and Microsoft combined. Before this format, there was no common standard, so broadcasters have to store the same media in multiple formats, which was costly.

Many media companies and CDNs are moving to this format. Read more here.

4. MSS (Microsoft Smooth Streaming): This format was launched in the year 2008 and helped to stream the Summer Olympics 2008. It is used in Xbox One devices. It’s not a very famous format.

So now, we are aware that we need other formats than mp4 to stream video content. But we need to produce mp4 files first and then we can convert them to the above-mentioned formats.

From now on, I will prefer the HLS format in this article.

Convert Files from MP4 to HLS Format

Though there are many great tools that can do this, I prefer using FFmpeg. It is a great tool to convert your files from one format to another. Also, it has a node.js library that can be used with node.js.

But to have a quick turnaround and save development cost, I was looking for a ready-made infrastructure and came across AWS media services, only to discover that it was the perfect choice for this task.

Setting Up AWS Cloud Infrastructure for Video-On-Demand

To get started quickly, I found this AWS ready-made cloud formation template. All tools and architecture of this solution have been shown in the below-given image-

Source of reference article image here.

This solution uses s3 buckets, AWS step functions, Media Convert, media package, AWS lambda functions, DynamoDB, cloud watch, CloudFront, and SNS service.

The cloud formation template I mentioned above, comes with HLS, CMAF, MSS, DASH formats. So when you pass on one Mp4 file, media convert will convert in all formats listed above. If you read about the pricing of media convert then you will find that it costs you a fixed rate per minute multiplied by the number of formats.

So if you keep more formats then cost will be high. Thus, to customize the template as per your requirements, you need to clone the following repository-

awslabs/video-on-demand-on-aws

To customize this template, you will need to have basic knowledge of node.js and python and some knowledge of how to list the tools of AWS. By the way, sometimes the template does not work in other regions then default. To fix this problem you can follow this link.

So now you can go to cloud formation and select either the default template or the customized template and launch the stack after filling the questionnaire.

You will now get two s3 buckets. One will be a source bucket and another will be the destination bucket. In source bucket, you will be uploading source video (mp4), once the uploading gets completed, step function will trigger media convert and it will convert your file into the decided format.

Once the conversion is done, it will store the converted file into the destination s3 bucket and the file will be ready for ingest by media package and CloudFront. You will be notified by SNS with the converted ready URL. Now, you can play this URL with any popular player.

Integrate this Stack With Backend

Your backend stack does not need to be aware of this whole stack. For the backend, there is a black box that has a bucket where we drop files which further converts the file and we get URLs to ingest.

So make a connection with the source bucket, upload the file to the s3 bucket. Once conversion completed, to get to know the file status, you will need to make a Webhook that will be triggered and notified with conversion status.

There can be another way by updating the lambda function which can directly call the Webhook without involving SNS. I am not writing the actual code to upload the file on s3 as there are 100s of good articles to demonstrate how to upload a file on s3. Rather I preferred to upload directly via frontend, for that you can generate a signed URL from backend and send it to frontend and upload from there.

Summary

This sort of ready-made solution gives an edge over the tools that we need to set up ourselves. It saves a lot of development costs as well as time and scales well as per demand. If an urgent need does arise then it makes sense to spend more in terms of development cost to save infrastructure cost.

In case you are looking for a team to develop Video-on-demand or live video streaming solutions, you are ever-welcomed to our company.

For any questions or feedback about the article, please write a comment below. If you liked the article then clap for it. Do you know you can clap more than 50 times??

How to Set Up Cloud Infrastructure for Video-On-Demand (VOD) Using AWS and Node.Js was originally published in Minds Verse | HabileLabs on Medium, where people are continuing the conversation by highlighting and responding to this story.

I am working on a project where we have a React web app, React Native app and another React Native app which is built using expo. All these three projects share a common backend, service layer and share redux logic.

There are some other common components as well that can be used across react native and expo app.

So, we needed an architecture to avoid duplicate code across the projects. I stopped for a moment and thought, what could be better than the monorepo architecture? It will also solve the problem stated above.

The Monorepo architecture provides the leverage to reuse much of the service layer, redux related code, and other shareable pieces of code across the components.

In the tutorial below, I will show step by step how can you use react web, react native and react native Expo project in one monorepo.

Let’s check out what exactly is a Monorepo??

Monorepo??

As stated by Wikipedia-

A monorepo, syllabic abbreviation of monolithic repository, is a software development strategy where code for many projects is stored in the same repository.

In simple words, monorepo contains more than one project code, which allows us to share code between many projects. Each project can have its own build and deployment system or can share build systems.

Many companies, including Google, Twitter, Facebook, etc. follow this process.

Now, I will discuss all the things that we used, the challenges we faced and resolved during this journey.

You can also take the help of the demo repository I created. (Link is given at the end of this tutorial)

Getting Started with Monorepo for React and React-Native

We decided to use yarn-workspaces for our use-case. Lerna is an excellent tool to manage yarn workspaces.

As described on the Lerna website about itself -

Lerna is a tool that optimize the workflow around managing multi-package repositories with git and npm.

To use Lerna, we will first need to install it. I am assuming you’ve already had Node.js and npm installed in your system.

#Installing Lerna 2.x

$ npm install --global lerna

#Creating project repository

$ git init lerna-repo && cd lerna-repo

#Turning folder into Lerna workspace

$ lerna init

Your repository will look like

lerna-repo/
  packages/
  package.json
  lerna.json

Now, you are ready with Lerna Workspace. Here, the packages, as per the name dictates, will contain different modules.

Let’s start adding a React js project into packages-

Create React App into Monorepo

#Creating app in packages folder

$ npx create-react-app <app-name>

#Example

$ npx create-react-app web-app

Please note that NPX supports only npm 5.2+ and higher versions, so if you have a lower version then you definitely need to upgrade it.

Once it is completed, go to the root folder of your repository and run-

$ yarn install

All the required modules will be installed and hoisted to the root folder by this command.

To start the web application-

$ lerna --scope=web-app run start

Congrats!! You are done with your first package.

Add React Native App Package

Go to the packages folder and run the following command-

$ npx react-native init <App name>

That is,

$ npx react-native init NativeApp

It will create all the folders and files required for the native app.

Once the process gets completed, go to the root folder and install packages again-

$ yarn

It will create React Native and other dependencies to root in npm_modules of monorepo. However, create-react-native-cli command expects react-native to be inside the package. If we still try to run it, there will be an error.

To fix this issue, we will use the yarn-workspaces nohoist feature.

In workspaces key of JSON package, we will add-

"nohoist": ["**/react-native", "**/react-native/**"]

Now, we’re gonna install packages again using yarn command.

$ yarn

Then we can start the apps using the following commands.

#Starting the android app

lerna --scope=NativeApp run android

#Start iOS app

lerna --scope=NativeApp run ios

Please note that an iOS app will work in MacBook only.

Well, now you have a repository that has both React web app and React Native mobile apps.

As we move further, we will try to add a React-Native expo project in this Monorepo as another package. If you don’t need an expo project, then you’re done here. You can stop right here!

Add Expo App Package

Let’s start by creating an expo project in the ‘packages’ folder.

Inside the folder, run the following command.

$ expo init <project-name>

That is,

$ expo init ExpoApp

It will create the project structure and will install the packages. Once completed, you have a working expo project in hand. But for now, we need to make it work as a monorepo.

First, delete the npm modules, then, go to the root folder and install packages again-

$ yarn

It will install npm_modules in the root folder and link them to the expo package.

But expo projects do not work on Monorepos. In order to finesse the expo project to make them work together with yarn workspaces, we will use expo-yarn-workspaces package.

How to Make Expo Work with Monorepos??

1. Add expo-yarn workspaces as devDependency to the expo project, inside the ExpoApp folder.

$ yarn add --dev expo-yarn-workspaces

2. Add a postinstall script to package.json.

3. Add "postinstall": "expo-yarn-workspaces postinstall" under the "scripts" object in the app's package.json file.

As per the documentation, expo-yarn-workspaces work only on macOS and UNIX based systems, Windows is not supported.

If we want it to work on Windows as well, then we need to make slight modifications to it.

Firstly, remove the postinstallscript from package.json and move it to the main package.json-

"postinstall": "cd ./packages/ExpoApp && expo-yarn-workspaces postinstall"

I tested the above workaround on macOS & Windows, and guess what?? It works like charm.

4. Now, define the entry module in the "main" field of package.json.

5. Specify "__generated__/AppEntry.js" as the value of the "main" field in package.json

Here is how the final package.json will look like-

{
  "name": "root",
  "private": true,
  "devDependencies": {
    "lerna": "^3.20.2"
  },
  "dependencies": {
    "metro-config": "^0.56.0"
  },
  "scripts": {
    "android": "lerna --scope=NativeApp run android --stream --",
    "ios": "lerna --scope=NativeApp run ios --stream --",
    "web": "lerna --scope=web-app run start --stream --",
    "expo": "lerna --scope=ExpoApp run start --stream --",
    "postinstall": "cd ./packages/ExpoApp && expo-yarn-workspaces postinstall"
  },
  "workspaces": {
    "packages": [
      "packages/*"
    ],
    "nohoist": ["**/react-native", "**/react-native/**", "**/expo", "**/expo/**"]
  }
}

6. Create metro.config.js in ExpoApp root folder with the following content-

const { createMetroConfiguration } = require('expo-yarn-workspaces');

module.exports = createMetroConfiguration(__dirname);

5. Reference metro.config.js in the app.json file inside the expo key.

"packagerOpts": {
  "config": "metro.config.js"
}

Now, go to the root folder and install packages again, using $ yarn .

#Start expo app

$ lerna --scope=ExpoApp run start

It will successfully start the expo app. But when you scan the app code on it, you will get an error as ‘react-native not found’.

As we said earlier that React Native should not be hoisted but the expo package is still hoisted. As a result, expo cannot find React-Native.

So, we need to update the hoisting of packages inside the package.json file.

"nohoist": ["**/react-native", "**/react-native/**", "**/expo", "**/expo/**"]

After updating the package.json file with proper hoisting, we need to install the packages again using $ yarn .

Now try starting the expo project again-

$ lerna --scope=ExpoApp run start

Wow!! You’ll see that the Expo app has started working inside the monorepo environment.

Together with the expo project, you can run the React web app and React Native projects as well.

Here is the full folder structure-

You will find the full code example here.

habilelabs/expo-react-react-native-monorepo-example

All the code is quite simple and straightforward. I hope I’ve made every step very clear. Furthermore, if you have got any queries, feel free to reach me out. Stay tuned with us for more similar Tech Blogs.

Your feedback, suggestions, and comments are most welcome.

Introduction

Node.js is a JavaScript platform for general-purpose programming that allows users to build network applications quickly. By leveraging JavaScript on both the front-end and the back-end, development can be more consistent and be designed within the same system.

There are 100s of articles which showcase to install specific version of nodejs on ubuntu machines, but it hard to find if you are willing to install one specific version at one place

Prerequisites

This guide assumes that you are using Ubuntu 16.04. Before you begin, you should have a non-root user account with sudo privileges set up on your system.

Please follow following steps to install node.js on server.

$sudo apt-get update

# for Node.js v4 
$curl -sL https://deb.nodesource.com/setup_4.x | sudo -E bash - 

# OR for Node.js v5 
$curl -sL https://deb.nodesource.com/setup_5.x | sudo -E bash - 

# OR for Node.js v6 
$curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash - 

# OR for Node.js v7 
$curl -sL https://deb.nodesource.com/setup_7.x | sudo -E bash -

# OR for Node.js v8 
$curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -

# OR for Node.js v9 
$curl -sL https://deb.nodesource.com/setup_9.x | sudo -E bash -

# OR for Node.js v10 
$curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -

# OR for Node.js v11 
$curl -sL https://deb.nodesource.com/setup_11.x | sudo -E bash -

# OR for Node.js v12 
$curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -

$sudo ln -s /opt/node/bin/node /usr/local/bin/node 
$sudo ln -s /opt/node/bin/npm /usr/local/bin/npm

$sudo apt-get install -y build-essential

You can check your installation via node -v command. This will return you version of node.js you just installed.

Please note if you which ever you major version number you choose it will install the stable LTS version of that range.

Originally published at http://www.morwalz.com .

How To Install Node.js on Ubuntu 16.04 and on 18.04 was originally published in Minds Verse | HabileLabs on Medium, where people are continuing the conversation by highlighting and responding to this story.