TypeScript Node.js relationship – professionals, cons, JS to TS migration

You’re utilizing Node.js to create environment friendly apps? Good for you! However is your growth course of simply as environment friendly? TypeScript can go an extended approach to bettering your Node.js mission! I used to be capable of notice it first-hand throughout a current mission of mine. I’m going to make use of it for instance to evaluation the TypeScript Node.js relationship and present you why and methods to transfer from JS to TS in a Node utility.

By the point I inform you all about my mission, you’ll come to a placing realization:

Loads of its points may have been prevented just by switching from JavaScript to TypeScript.

Whereas I’m on it, I’m going to reply a few questions:

  • What sort of benefits does TypeScript maintain over JavaScript on the subject of Node.js apps?
  • How (and when) emigrate from JavaScript to TypeScript in a Node.js mission?
  • Learn how to begin a brand new Node.js mission with TypeScript?

Earlier than I’m going there, it could be encouraging to check out the current state of TypeScript in 2022.

TypeScript recognition in 2022

The preliminary TypeScript launch was modest and the brand new JavaScript superset lacked mature IDE help. When a Microsoft workforce made it public in 2012 to assist kind out a few JavaScript shortcomings, the builders couldn’t have suspected that in the future it may get this huge. 

And but right here we’re in 2022 – at a time when TypeScript is a powerhouse on this planet of internet growth. Simply how a lot of a powerhouse, you might ask?

Nicely, in accordance with our State of Frontend 2022 report, as many as 84,1% of all builders surveyed used TypeScript over the past 12 months.

% of builders who answered “sure” when requested about utilizing TypeScript within the final 12 months

These are largely frontend builders, although. What a couple of TS Node dev?

In comparison with the frontend, TypeScript was considerably slower to dominate JavaScript on the net server aspect. Node.js, being the preferred JavaScript runtime atmosphere, ultimately made it doable for TypeScript for use for Node growth (in addition to another compile-to-JS languages), however it continues to solely help JavaScript absolutely. What’s extra, numerous instruments from the broadly understood Node.js atmosphere now help TypeScript, together with the more and more in style NestJS framework.

Ryan Dahl, one in every of Node’s authentic founders, is now selling Deno – a TypeScript-first Node.js various. Nonetheless, it’s nonetheless mild years behind Node.js by way of recognition and group help.

And that’s simply too unhealthy as a result of I consistently come throughout Node.js initiatives that would use some TypeScript! Why? Let me inform you one thing a couple of mission I not too long ago accomplished that actually succeeded… in annoying me.

Supply: Wikimedia Commons

Ryan Dahl is likely one of the creators of the Node.js runtime. He continued to work on it till 20212. Finally, he went on to create a Node.js various – the TypeScript-based Deno. He defined his views on the event of Node within the lecture 10 Issues I Remorse About Node.js.

The legacy Node.js mission – woes of JavaScript

From one in every of our prospects, I inherited a legacy utility written in Node.js. It had Specific.js on the backend and React on the frontend. What’s extra, the appliance had no unit exams by any means. You may think about that studying the codebase was fairly painful with out TypeScript.

Each time I needed to make certain what a given argument is, I needed to dig into the code and analyze it totally. And even after I did simply that, I nonetheless skilled surprising conduct, particularly when the variable in query had an advanced construction full of varied dependencies. 

I feel that each dev needed to face a scenario when it’s important to go six capabilities backward to investigate how sure parameters would behave within the final operate. As I used to be performing this thankless job, I couldn’t cease considering how a lot simpler it might have been if it had been written in TypeScript.

In what methods would TypeScript make it higher precisely? There are not less than 4 areas I’d like to say:

  • Predictability,
  • Maintainability,
  • Scalability,
  • Testability.

Let’s take it from the highest.

Node.js, TypeScript, React, and Specific are all amongst The Software program Home’s high applied sciences. Try our Tech Radar to search out out extra about our tech stack.


The principle difficulty with JavaScript on this legacy mission is that you’ll be able to’t make certain how a variable will rework throughout code execution. Right here, the variables included some advanced objects with a number of nested fields. Generally, an object key would get misplaced someplace by the point one other methodology that wants it receives the variable as an argument. After which growth – a bug strikes with obj.secret is undefined. TypeScript’s static varieties make it straightforward to detect such bugs early on.

One other time, seemingly out of nowhere, a subject that has at all times been an array magically transforms into an integer.

Certain, there are some options to that. However it will get actually time-consuming when it’s important to run a test with hasOwnProperty or surprise what’s one of the simplest ways to search out out if a variable is an array each time you wish to use it.


TypeScript ensures that you already know what to anticipate from variables you’re employed with. Admittedly, establishing the interface for objects takes loads of time to start with,  however it saves rather more throughout debugging. 

When it’s important to delete an object subject, you could use a destructor. That manner, TypeScript forces you to consider what you’re doing. Consequently, TypeScript does its greatest to stop you from capturing your self within the knee each time you modify your code.


The unpredictability of JavaScript makes it more durable so as to add new options to the mission. You would possibly really feel unsure about what’s returned from the strategy you used. Whenever you use TypeScript, you don’t want to recollect all that data and you’ll focus merely on writing new code.


Testing can be affected by the lack of static typing in JavaScript. TypeScript requires much less testing code than JavaScript to realize the identical quantity of certainty in regards to the utility. Even writing exams is less complicated since TypeScript helps you arrange appropriate mocks by implementing outlined interfaces.

TypeScript continues to get higher and higher! Don’t consider it? Try the brand new TypeScript options article to get the most recent data.

When to maneuver to TypeScript

Chances are you’ll be questioning when is the perfect second to maneuver from JavaScript to TypeScript code. The reality is that on the subject of present apps, the method will inevitably be troublesome and time-consuming. Probably, you’ll hit the wall and surprise why you even began doing this TypeScript mission within the first place. 

Having mentioned that, the earlier you flip to the TypeScript compiler the higher. Larger apps will certainly take much more time emigrate to TypeScript so it’s best to make your determination rapidly, early within the lifespan of your Node.js utility. Sustaining a rising Node.js app with out static varieties from TypeScript goes to get more and more arduous. It’s simply unimaginable to recollect what each variable does within the code. 

When emigrate your Node.js app to TypeScript ASAP?

  • When your utility handles information of nice worth and significance, particularly cash.
  • When the appliance strikes from the proof-of-concept state into the actual world.
  • When you already know that the appliance goes to get help for a number of years going ahead.
  • When you’re going to preserve including new options to your utility.
  • When the appliance codebase remains to be comparatively small.

There’s another reason of a distinct form that I’d wish to level out. It’s one thing known as “trusting your intestine”. For instance, when including a brand new function in JavaScript to your Node.js mission, you might really feel uneasy, like it’s a matter of time earlier than all of it explodes. 

The optimistic aspect of the migration course of is that you’ll be taught much more about your code and possibly encounter loads of refactoring alternatives.

The extremely scalable ticket platform of Reservix was developed with Node.js and TypeScript. Learn the full case examine.

The implementation – shifting an present Node.js app from JavaScript to TypeScript

Earlier than you can begin shifting the codebase of your Node.js utility to TypeScript, you could add some parameters to your TypeScript configuration file tsconfig. Particularly:

  • allowJs so to import .js information into .ts information,
  • checkJs so to report errors in JavaScript information. 

Now, attempt to get an error-free compilation whereas utilizing any varieties. Then, clear up error points incrementally and exchange any sort with interfaces. To start with, you don’t must have varieties for every part. You may add varieties to core functionalities of your Node.js utility step-by-step. Bear in mind to put in varieties for packages.

From JavaScript to TypeScript

I wish to offer you an instance of how I might method shifting a bit of JavaScript code in a Node.js mission to TypeScript. First, you could set your first TypeScript file (a tsconfig) file with allowJs and checkJs. You additionally must set a strict sort test however you’ll be able to modify sort checks to your wants as described right here.

Right here is an instance JavaScript file from which I’m going to extract functionalities to TypeScript lessons.

The file sends an invite e-mail and a request e-mail relying on the emailType parameter obtained from the request. Out of the file above, I created a number of TypeScript information utilizing OOP (Object-oriented programming) guidelines such because the single accountability rule and encapsulation precept.

Now, I must create a generic EmailService class.

The EmailServiceConfig interface I imported defines the construction of dependencies that this class takes upon setting up. In a scenario like this, it’s a good suggestion to make use of some type of dependency injection container akin to Awilix. It helps handle objects with loads of dependencies. I skipped it right here for simplicity’s sake.

I additionally created a nodemailer transporter within the constructor. Then, I made an interface to outline the sendMail methodology parameters. You may see that the EmailService class is extra self-described and error-proof and that it’s only answerable for sending emails. To that finish, it must create nodemailer. It additionally makes use of the next config file:

Whenever you create an EmailService object, you could go it to it as a dependency like this: 

const emailService = new EmailService(emailServiceConfigFactory(course of.env)); 

That manner, you’ve validated your config and you already know for positive that you’ve every part essential to create a transporter for nodemailer

Splitting tasks between lessons

Now, I’m going to indicate you a extra particular class. It’s answerable for sending invitation emails.

Other than sending an invite e-mail, this class creates a JSON Net Token (JWT) in an effort to make a magic hyperlink. As a dependency, it takes the aforementioned EmailService. It additionally makes use of the InvitationTemplate, which is solely a set of exports:

How are you going to use these lessons? Contemplate the next instance:

It could have seemed prettier with a dependency injection container, however TypeScript will remind you about mandatory dependencies anyhow. With these lessons, you cut up loads of tasks between them. Now, everytime you get into a category, you’ll be able to perceive what’s going on rather more rapidly. The lessons are simpler to check as nicely.

Shifting an present app to TypeScript is troublesome.

Rent devs which have already executed this time and time once more.

Constructing a TypeScript app in Node.js from scratch

As you’ll be able to see, transitioning your present code base to TypeScript is difficult. Oftentimes, you’ll have to run with TypeScript and JavaScript code on the identical time and clear up their issues concurrently. It’s manner simpler to begin a brand new mission in Node.js with TypeScript.

If you wish to begin your TypeScript Node.js mission from scratch, you could set up Node.js, after which initialize the mission with npm init. Then, you undergo the wizard and fill within the mandatory information. 

As soon as the initialization is full, set up TypeScript with the npm set up typescript –save-dev command. Add varieties for Node with the npm set up @varieties/node –save-dev command. 

Now you’ll be able to create an index.ts file that has your beginning “Hiya World!”. Then, run the npx nodemon ./index.ts command

To take a step additional, arrange your tsconfig.json. It describes the best way the compiler treats your TypeScript information when compiling them to JavaScript. For this mission, I’m going with one thing like this:

It’s a great second to create some atmosphere variables. Since each mission has a ‘.env’ file, create one and set some variables akin to STAGE to point in case you are within the manufacturing or growth atmosphere. Then, set APP_NAME and PORT. 

At this level, the .env file ought to appear to be this:

The following step could be so as to add some validations for these atmosphere variables. First, you could set up the required packages utilizing the npm i have a good time ts-pipe-compose command. That might make the appConfig.ts file appear to be this:

What occurred right here? Firstly, I put in have a good time, which is middleware for joi. The have a good time bundle might be additionally helpful later for validating parameters from HTTP requests to your Node.js utility. I additionally put in the ts-pipe-compose bundle. It makes it doable for me to carry out pipeline(loadConfig, validateConfig). With that, each time I name appConfigFactory(args), it ends in validateConfig(loadConfig(args)). To place it in several phrases, it first hundreds the config after which validates it towards your outlined joi schema. 

Now you can use appConfigFactory in your index.ts file, through which I can even outline the routes of the appliance. For that, I would like to put in categorical and dotenv packages first. The related instructions are npm i categorical dotenv and npm i –save-dev @varieties/categorical respectively.

Now you can create your app.ts file, which has the category that initializes your Node.js app.

Create the index.ts import app in it and run the init methodology:

To sum all of it up, the construction of directories in your mission ought to now look as follows:









With a purpose to run the mission, simply use the npx nodemon ./src/index.ts command. Whenever you ship the get request with the arg param and a string worth to localhost:3337, it’s best to get the next response: “Nodejs, TypeScript, Specific App”. You also needs to get the string worth of your param. In any other case, you’re going to get an error that claims: “Validation failed”. 

When every part is alright, you’ll be able to proceed to increase the mission, creating some fashions, and controllers with ample routes for every.

Final however not least, I wish to point out the mission listing construction. On the market within the wild, there are such a lot of initiatives with empty directories, created out of behavior and for no good cause. Don’t pressure your self to suit a brand new class into an present listing in your Node.js mission. Create a brand new one solely whether it is actually mandatory. 

Specific-boilerplate by The Software program Home

That will help you begin together with your new TypeScript Node.js utility, TheSoftwareHouse has created an categorical boilerplate. It helps a ton in establishing new initiatives. The entire boilerplate is predicated on docker containers so to begin creating very quickly. Other than that, it additionally has loads of helpful instruments. Remember to test this out.

Try the express-boilerplate by The Software program Home

Node.js TypeScript combo – developments & predictions

TypeScript is getting increasingly more consideration and rightfully so. 

In spite of everything, it helps you retain huge initiatives at bay. It makes it simpler to create good clear code. Consequently, increasingly more new and present instruments select to help TypeScript and even use it as its basis.

The JavaScript growth workforce is continually making an attempt to meet up with TypeScript by including loads of new options, as soon as solely out there in TypeScript. These days, vanilla JavaScript has help for decorators, and kinds for IDE. The ES2022 specification went so far as introducing non-public variables. 

However whether or not NodeJs is ever going to be TypeScript-first is extremely uncertain as a result of big quantity of bags that Node.js has generated through the years.

Deno and Bun each begin with clear sheets and supply native help for TypeScript. Nonetheless, builders are nonetheless hesitant to make use of both of them in a manufacturing atmosphere. Evidently Deno is far nearer to being prepared for some manufacturing initiatives.

It stays to be seen whether or not Deno will emerge as a severe various to Node.js
Supply: https://deno.land/

The most effective devs preserve tabs on the most recent improvements of their fields.

As a part of our inner workshops, our Node.js and frontend builders be taught all in regards to the newest strategies and approaches. Maybe they will use their information to your benefit?

Conclusions & classes discovered

As you’ll be able to see, TypeScript actually does make a distinction, particularly in an enormous mission.

  • As a result of its advantages for each simplicity and maintainability, TypeScript is a large assist for each builders who’re solely beginning with a mission and people who have been engaged on it for years.
  • TypeScript takes away loads of the mission overhead, giving builders extra spare time and mind capability to give attention to totally different features of coding than upkeep and testing, particularly the event of recent enterprise logic.
  • Shifting to TypeScript is more durable with an present JavaScript codebase, however it isn’t mission unimaginable.
  • With a purpose to make up your thoughts about migrating to TypeScript, you could reply questions akin to: How lengthy will the mission be maintained? How huge is it? What number of of our builders already know TypeScript?

When the solutions point out that implementing TypeScript might be comparatively straightforward and supply its advantages in the long term, it’s best to positively go for it!

Patryk Rosenkiewicz

Patryk Rosenkiewicz

Node.js developer

Patryk is an internet developer with 5 years of expertise. He set to work on an excellent number of initiatives written in Perl, Bash, C++, Ruby, PHP, Python, and JavaScript. He loves studying new issues and caring for his two canines.


Leave a Reply

Your email address will not be published.