DEV Community: Yash Solanki

require vs import in NodeJs

Yash Solanki — Fri, 07 Oct 2022 14:51:43 +0000

Introduction

If you’re a NodeJs developer, you might have come across some code snippets which use require() to import modules while others use import for the same purpose; which might have got you to wonder, which one of these is correct and which should you use in your project?

In this article, we’ll try to answer all such questions and clear the air around the difference between both the import techniques.

Scope

This article will walk you through the difference between the two import techniques in NodeJS, or, in general, the difference between the two module systems which use these import techniques.
This article does not cover the difference in syntax for default, named, and mixed exports in both the module systems.

Modules and Module systems

Module systems enable us to structure and organize different modules in our Javascript code

By default, Node uses CommonJS, while ES Modules is the Javascript official standard for writing reusable code on both client and server.

As we are already aware, each file in Node is treated as a separate module.

A module is a Javascript file containing related code. So as our application gets bigger, we can split it into different files viz. modules, which makes our code more readable and also allows us to reuse the code in different parts of our application

The code inside these modules is not available globally i.e. you cannot directly access the variables, functions, and classes defined in one module in any other module.

Instead, we have to explicitly tell NodeJS which parts of a module must be exported and which parts must be imported into a file. The module system helps us to structure and organize these modules.

In this article, we’ll try to understand two commonly used module systems - CommonJS and ECMAScript or ES Modules.

CommonJS vs ES Modules

require is used to import modules in CommonJS while import is used in ES Modules.

Since require and import are just small parts of two different module systems, it makes more sense to differentiate between CommonJS and ES Modules to get a larger picture.

CommonJS (Uses `require` for importing modules)

CommonJS is the legacy module system implemented by NodeJS. In CommonJS, we can export modules using module.exports and import them using require
We can import various built-in modules, third party modules (installed via npm), or any of our local modules using require

//calculate.js
function add(num1, num2) {
    return num1 + num2;
}

function subtract(num1, num2) {
    return num1 - num2;
}

module.exports = {add, subtract};

//index.js
const { add, subtract } = require('./calculate');

console.log(add(1, 2)); // 3
console.log(subract(3, 2)); // 1

ES Modules (Uses `import` for importing modules)

While Javascript did not have any built-in module system in the beginning, Node used CommonJS as its default module system
But, in ES2015 (also commonly known as ES6), Javascript got its own module system - ES Modules, which has been widely adopted ever since, and NodeJs also added support for the same.

We can use ES Modules instead of the default CommonJS module system in Node by either

Changing the extension of the file from .js to .mjs

So, in the example above, if we change the extension of the files to .mjs, we can use the ES6 syntax for importing and exporting modules

//calculate.mjs

function add(num1, num2) {
    return num1 + num2;
}

function subtract(num1, num2) {
    return num1 - num2;
}

export { add, subtract };

//index.mjs
import { add, subtract } from './calculate.mjs';

console.log(add(1, 2)); // 3
console.log(subract(3, 2)); // 1

Or instead of changing the file extension, we can also add a property "type": "module" at the top-level of package.json to use ES Modules across our Node application

{
  "name": "nodejs-app",
  "dependencies": {
    ...
    }

    "type": "module"
}

Difference between CommonJS and ES Modules

CommonJS modules can be imported at any place in the program while ES modules have to be imported only at the beginning of the program

const express = require('express');

function getData() {
    const data = require('./data');  //This is valid
    //Do Something
}

Since CommonJS modules are imported dynamically at runtime, module bundlers like webpack cannot remove unused modules from the production build, thus increasing the size of the bundle
CommonJs modules are loaded synchronously, which means that the modules are processed one by one, which can cause performance issues in large scale applications. ES Modules, on the other hand, are imported asynchronously, thus offering performance benefits as the application scales
Widely used CommonJs variables like __dirname , __filename and NODE_PATH ********are not available in ES Modules
ES Modules is the official standard and most of the frontend frameworks like React, Vue etc use it, so it offers consistency in client and server side code

Which one should you use?

If you want consistency in the backend and frontend, you should consider using ES Modules as it is the official standard for Javascript.
Node v9 or below versions do not support ES modules. Though it’s very unlikely, but if you’re working on a project with these node versions, you won’t be able to use ES Modules
In conclusion, it doesn’t matter if you’re using CommonJS or ES Modules as long as you’re confident with the choice.

Noob’s guide to using any Google API in NodeJs

Yash Solanki — Sat, 18 Jun 2022 07:15:22 +0000

Google offers multiple services to its users and also offers developers the option to build super cool stuff by integrating these services into their apps using their APIs. You can check the list of all the apis provided by Google here

In this article, I’ll walk you through the initial authentication step for using Google APIs. Lets jump right into it

Creating a project in Google Cloud Console

To generate credentials for Google APIs, we need to create a project in Google Cloud Console. Sign in to Google Cloud Console with your google account and create a new project and follow the below steps:

Step 1: Enabling Google API

In the sidemenu, select APIs and Services -> Library -> Search for the Google API you want to use and enable it

Google offers two basic types of credentials to access their API - API key and oAuth 2

API key is used when accessing publicly available data like Google Maps
oAuth 2 is used when accessing private data like a user’s Gmail account or Google drive

Getting oAuth credentials involves setting up an oAuth consent screen. You can skip this step if you’re looking only for API Key authentication

Step 2: Setting up the OAuth Screen

Inside APIs and Services -> OAuth Consent Screen -> Select User Type. You can External for testing
On the next screen, enter all the application details
In Scopes section, click on Add Scopes. Each service offers different levels of permissions (i.e. scope) to client data. You can select the scope as per your project requirements.
If your application is still in Testing phase and you selected External user type previous step, provide emails of all the users who can access your app
Check the app summary and click Save

Step 3: Generating Credentials

oAuth Client ID
- Again in APIs and Services, open Credentials -> Create Credentials -> oAuth Client ID
- Select your Application Type and add
  - Authorised Origin - You can use localhost with port no. http://localhost:3000 if your app is not hosted
  - Callback URL - This is the url where Google will send the response after OAuth. Again for locally hosted apps, you can use something like http://localhost:3000/auth/google/callback
API Key
- Generating API Key is fairly straight forward. Inside APIs and Services, select Credentials -> Create Credentials -> API Key

Connecting our Node Project to Google API

For connecting to Google API, we’ll use the Node client library - googleapis. Install it in your project using npm i goolgeapis

Now to store the cloud project credentials in your app, install dotenv and create a .env file

For oAuth2 authentication, add CLIENT_ID, CLIENT_SECRET and CALLBACK_URL in the environment file.
For API Key auth, just add the API_KEY and skip the next step

Step 1: Creating an oAuth2 client

In our app, we need to create a Node oAuth2 client using our generated credentials which validates our app as a valid client.

const { google } = require('googleapis');
require('dotenv').config();
const { CLIENT_ID, CLIENT_SECRET, CALLBACK_URL } = process.env;

const oauth2Client = new google.auth.OAuth2(
  CLIENT_ID,
  CLIENT_SECRET,
  CALLBACK_URL
);

In order to authenticate the users of our app and get consent to access their data, we need to generate a unique url based on our project scope. So this allows our app to make requests to Google apis on behalf of the user.

//This method returns a url where the users can see the oAuth consent screen
function getGoogleAuthURL() {

  // Add all the scopes required by your app in this array. 
  // For example, if the scope needed by your app is /auth/calendar, 
  // add it as https://www.googleapis.com/auth/calendar in the array
  const scope = [
    'https://www.googleapis.com/<scope-that-you-selected-earlier>'
  ];

  return oauth2Client.generateAuthUrl({
    //'offline' mode will return a refresh token which we can save in our database to access the user's data in the future
    access_type: 'offline', 
    scope,
  });
}

We can now create a separate route to redirect our users to the generated url

app.get('/auth/google', (req, res) => {
  res.redirect(getGoogleAuthURL());
});

When the user is redirected to the callback route, we can get the user details and save it in our DB and perform any other operation as needed

async function getGoogleUser({ code }) {
  // This will return an object with the access_token and refresh_token
  const { tokens } = await oauth2Client.getToken(code);
  oauth2Client.setCredentials({
    refresh_token: tokens.refresh_token
  });

  // Fetch the user's profile with the access token and bearer
  const googleUser = await axios
    .get(
      `https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=${tokens.access_token}`,
      {
        headers: {
          Authorization: `Bearer ${tokens.id_token}`,
        },
      },
    )
    .then(res => {
      return { data: res.data, refresh_token: tokens.refresh_token };
    })
    .catch(error => {
      throw new Error(error.message);
    });
    return googleUser;
}

app.get('/auth/google/callback', async (req, res) => {
  try {
    const googleUser = await getGoogleUser(req.query);

    //Get user id, email and name from the response
    const { id, email, name } = googleUser.data;

    //You can store this refresh token in your db for future access
    const refreshToken = googleUser.refresh_token;

    //Store the data in DB and redirect to some other page

  } catch(err) {
    //Error handling logic here
  }
})

Step 2: Authenticating API requests

We can authenticate all of our requests either at the global level or at a service level to avoid dealing with it in every request we send
For API Key authentication, just replace the oauth2Client with API_KEY

// Global authentication
google.options({
  auth: oauth2Client
});

// Service level authentication - Example with Google Drive service
const drive = google.drive({
  version: 'v2',
  auth: oauth2Client
});

And voila! Our Node app is now authenticated to use Google APIs. You can now easily GET and POST data to any of the Google apis provided you have defined the right scope.

You can checkout endpoints for any of api in Google Api explorer and refer the googleapis documentation here

Thank you! Do let me know in the comments if you have any questions.

Stay healthy, Stay happy, Stay safe. Cheers!