DEV Community: Salman Arefin

npm and everything you need to know about the package.json

Salman Arefin — Wed, 27 Nov 2024 10:23:09 +0000

What is npm?

npm is a package manager for NodeJS. It is also the largest single language code repository on earth and a tool for installing and managing packages from the repository on the command line.

What is a package?

The npm registry consists of numerous packages or libraries that can be downloaded, installed, and used as a dependency in a NodeJS project. An npm package is a reusable piece of code published to the npm registry. It helps developers improve their workflow by incorporating functionality, thereby reducing the need to write redundant or repetitive code.

How do I install a package in my NodeJS project?

By using the CLI command npm install

npm install: This command will install all the dependencies mentioned in the package.json in the node_modules folder.
npm install <package-name>: Installs the package in the current project directory (inside the node_modules folder). The package is accessible only within that project.
npm install -g <package-name>: Installs the package system-wide, making it available from anywhere on your machine.
npm install <package-name>@<version-number>: Installs a specific version of that package.
npm install <package-name> --save-dev: Installs the package and puts it in the devDependencies block of package.json
npm install <package-name> --no-save: Installs the package but does not add the entry to the package.json file dependencies.
npm install <package-name> --save-optional: Installs the package and adds the entry to the package.json file's optionalDependencies
npm install <package-name> --no-optional: This will prevent the installation of optional dependencies.

What is package.json?

package.json is a configuration file used in Node.js projects to manage project metadata, dependencies, and scripts. It acts as the heart of a NodeJS project.

What is the difference between `devDependencies` and `peerDependencies`?

devDependencies: These are packages and libraries needed only during development or testing. They are not included in the production code.

Installation:

npm install tslint --save-dev

peerDependencies: These are dependencies that the project needs to work on, but it expects the user who is installing the package to provide the dependency.

"peerDependencies": {
  "graphql": ">=10.0.0"
}

The above block means:

The project needs the package graphql to work.
It needs the version of the graphql package to be 10.0.0 or higher.
The package users must install GraphQL themselves.

Scripts in package.json

The scripts field in package.json defines commands that can be run using npm run <script-name>. Some scripts worth mentioning:

start: The command to start the application.

"start": "node index.js"

build: Used for production builds.

"build": "webpack --mode production"

test: Runs the unit test suite.

"test": "nyc"

dev: Starts the development server.

"dev": "nodemon index.js"

lint: Runs a linter to check code quality.

"lint": "tslint ."

clean: Cleans up build artefacts.

"clean": "rm -rf dist"

compile: Used to transpile source code into a different format (e.g., TypeScript to JavaScript)

"compile": "tsc"

publish: Used to publish the package to a registry like npm.

"publish": "npm publish"

Pre/Post Hooks: There are also pre/post hooks for scripts like preinstall, postinstall, prebuild, precompile, postpublish etc.
Custom scripts: Custom scripts can also be written in the package.json and can be just run using npm run <script-name>

npm package versioning

Major: When a feature is added with a breaking change in the functionality.
Minor: When a feature is added in a backward-compatible manner.
Patch: When a bug is fixed, which doesn't break any backward compatibility.

Version: 1.2.3

Here, 1 is major, 2 is minor, and 3 is patch.

NodeJS Modules [Simple Explanation]

Salman Arefin — Sun, 24 Nov 2024 07:44:12 +0000

What are modules?

Imagine you have an index.js file in your NodeJS project where you have used five functions. However, two of these functions might also be used in other files. So, instead of one file, you create three files in your project:

index.js
dependency1.js
dependency2.js

Here, each of these Javascript files is a module, and the way to export classes/functions and import them is basically the module system. A module system allows us to split and include code and import code written by us or other developers whenever required.

These modules are not just the Javascript files that exist in your project; they can also be any external package you have installed as a dependency in your project. Also, NodeJS has some built-in modules like http, fs, etc., which are available along with installation and can be imported without adding any external dependencies.

How can I export or import a module?

Two module systems are used in Node.

CommonJS (CJS)
ECMAScript Module (ESM)

You have read the kitchen-chef-waiter example in my previous blog; Similarly, if we compare modules with that, imagine CommonJS is an old big recipe book we needed to search and find a recipe, while ESM is a new aged digital app to see recipes.

CommonJS (CJS)

The older module system.
Modules are written in a simple format like:

// Export
module.exports = function SayHello() {
  console.log("Hello World!");
};

// Import
const GetHello = require("./hello-script.js");
SayHello(); // "Hello World!"

Synchronous: Loads modules one after another.
Works only in Node.js (not directly in browsers).

ECMAScript Modules (ESM)

The modern module system.
Modules are now more structured:

// Export
export function SayHello() {
  console.log("Hello World!");
}

// Import
import { SayHello } from "./hello-script.js";
SayHello();

Asynchronous: Loads multiple modules at the same time.
Works natively in browsers and Node.js.

Key Difference in syntax:
CJS: module.exports / require
ESM: export / import

How do I configure CJS or ESM in my project?

Open the package.json of your project.
Add:

{
  type: "module";
}

This tells NodeJS to interpret .js as ESM. If we don't add this, NodeJS will interpret it as CommonJS by default.

Modules in Typescript:

Sometimes, you can use ECMAScript modules but an old package you have imported is written in CommonJS. To handle these cases, we sometimes make sure the output Javascript code generated from the Typescript file comes in the common format, even though we have written the Typescript files in ESM format.

For this, we add the compilerOptions in the tsconfig.json of our project:

"compilerOptions": {
  "module": "commonjs",
  "target": "es6"
}

What happens then:
module: "commonjs": Outputs JavaScript using the CommonJS module system, which uses require and module.exports.
target: "es6": Ensures that the output JavaScript uses ES6 syntax and features like let, const, and arrow functions.

Input Typescript code:

import { readFile } from "fs";

const SayHello = () => {
  console.log("Hello World!");
};

export { SayHello };

Output Javascript code:

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SayHello = void 0;
const fs_1 = require("fs");
const SayHello = () => {
    console.log("Hello World!");
};
exports.SayHello = SayHello;

Introduction to NodeJS [Simple Explanation]

Salman Arefin — Fri, 22 Nov 2024 08:39:57 +0000

What is NodeJS?

An open-source and cross-platform Javascript runtime environment.
Runs on the Javascript V8 engine (which is the core of Google Chrome)
Single-threaded and uses asynchronous programming.

If NodeJS is single-threaded, how does it handle multiple requests?

Imagine you go to a restaurant where there is only a single chef. You order Pasta from the waiter. The waiter informs the chef about the order and other customer orders. The chef gets your Pasta order but realizes it will take time to boil your Pasta. Instead of waiting for your Pasta to cook, it keeps it in the stove to boil and meanwhile starts processing the other orders/

NodeJS works similarly.
Chef = Node.js' Main Thread (Node.js can only do one thing at a time on its main thread)

Waiter = Event Loop (The event loop takes incoming requests and decides how to handle them)

Kitchen Helpers = Worker Threads or OS Background Processes (Node.js delegates the work to helpers)

For example, in an I/O operation, when the web server is requested to fetch content from a file, NodeJS simply delegates the work to the OS's file system and gets ready to handle the subsequent request. When the file system responds, it handles that.

Why should I choose NodeJS over other backend applications?

Same language across the stack: Most front-end development uses JS frameworks like Angular, React, Vue, etc. It would be a massive advantage if the backend application were written in Javascript. Full-stack developers don't need to learn a new language for backend development.
Ideal for microservice-based architecture: NodeJS's single-threaded event-loop architecture is much more convenient for web developers than multi-threaded architecture, as there is no risk of available threads being finished when handling multiple concurrent requests.
Fast development: NodeJS is very lightweight, and NodeJS servers can be up and running quickly with little effort.
NPM: The NodeJS Package Manager is a vast library of code developers write worldwide. It can easily be used as a dependency in a project, shortening the effort to write extra code.

"NodeJS servers can be up and running quickly using little effort" - is it that simple?

YES.

const { createServer } = require('node:http');

const hostname = '127.0.0.1';
const port = 3000;

const server = createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

What this code does:

Uses the http module of NodeJS.
Configures the host and port.
Uses the createServer method of http module to create a server.
Whenever a new request is received, the request event is called, providing two objects: an http.IncomingMessage object and an http.ServerResponse object.
The created server listens to the host and port.

And that's it. Now, running node server.js, where server.js is the name of your code file, will make your NodeJS server "up and running."