Topic

Node.js runtime, modules & npm

Definition

Node.js is a JavaScript runtime built on the V8 engine that executes JavaScript outside the browser and provides operating-system APIs for files, processes, networking, environment variables, and package loading.

In simpler words

Node runs JavaScript on the server. It gives you server-side APIs and a long-running process; npm installs packages and runs package scripts.

Nest and Express both run inside Node, so runtime, module, package, and environment behavior still matters after a framework is added.

Open official example (opens in new tab)

After this you can

Distinguish Node, npm, Express, and Nest
Explain ESM imports versus CommonJS require
Read package.json scripts, dependencies, and devDependencies
Use process.env without committing secrets or assuming every value exists

Runtime, process, and server-side APIs

Definition

A Node process is an operating-system process running the V8 JavaScript engine plus Node APIs such as process, fs, path, streams, timers, and networking.

In simpler words

V8 executes the language; Node adds the server toolbox and keeps the process alive while work such as an HTTP listener remains open.

A browser supplies document, window, and DOM APIs. Node instead supplies process, Buffer, file-system APIs, sockets, and server-side streams.

process.argv contains command-line arguments, process.cwd() is the current working directory, and process.env contains string-valued environment variables. Validate required configuration at startup.

A Node API normally starts one long-lived process. Uncaught exceptions and unhandled promise rejections can terminate that process.

Validate configuration before listening

const port = Number(process.env.PORT ?? 3001);

if (!Number.isInteger(port) || port <= 0) {
  throw new Error('PORT must be a positive integer');
}

console.log({ cwd: process.cwd(), port });

Environment variables are strings or undefined. Convert and validate them once at application startup.

Modules, package.json, and npm

Definition

A JavaScript module exposes values through exports and consumes other modules through imports; package.json declares the package boundary, scripts, dependencies, and module conventions.

In simpler words

Split code into files with explicit imports. Let package.json describe how the app is installed, built, and started.

Modern TypeScript projects normally write ESM-style import/export and compile according to tsconfig.json. CommonJS uses require/module.exports.

dependencies are needed by the running application; devDependencies support development and build work. The lockfile records an exact resolved dependency graph.

Run package scripts through the workspace package manager. In a pnpm monorepo, filters select an app or package without changing dependency boundaries.

Module and package script

// env.ts
export const port = Number(process.env.PORT ?? 3001);

// main.ts
import { port } from './env.js';

// package.json
{
  "scripts": {
    "build": "tsc -p tsconfig.json",
    "start": "node dist/main.js"
  }
}

TypeScript compiles source modules; Node executes the emitted JavaScript selected by the start script.

Keep in mind

Validate environment values at startup and keep secrets out of source control.
Use the project’s package manager and scripts instead of ad hoc global installs.
When module loading fails, inspect package.json and tsconfig.json before changing import syntax randomly.

Test

Check your understanding

At least 10 questions — mix of concept, syntax, practical, and logic. Score ≥80% (enforced by the API) to save progress.

Checking your session…

15 questions · concept 5 · syntax 3 · practical 4 · logic 3

1. What is Node.js in a server project?

Concept

A JavaScript engine like V8 that only parses and compiles code without I/O APIsA transpiler that converts TypeScript into browser-ready JavaScript at build timeA process supervisor that watches and restarts crashed application processesA JavaScript runtime that runs server-side code and exposes OS APIs like filesystem and networking

2. What does npm primarily manage?

Syntax

The global system binaries installed outside any projectThe Node.js runtime version used to execute the projectThe compiled output bundle emitted into the dist directoryPackages and scripts declared in package.json

3. How should process.env values be treated at startup?

Practical

As booleans Node coerces from the strings "true" and "false" automaticallyAs values already type-checked against your TypeScript interfacesAs read-only constants Node freezes so they cannot be reassignedAs strings that must be parsed and validated before use

4. Why keep dependencies and devDependencies separate?

Logic

Production installs can omit tools needed only for build and testdevDependencies install faster because npm skips their transitive dependenciesOnly dependencies are recorded in the lockfile, so devDependencies stay unpinneddevDependencies load lazily at runtime while dependencies load at startup

5. Which claim about package.json scripts is true?

Concept

npm runs every script alphabetically during npm installOnly the reserved names start, test, and build are allowed as script keysScripts run in the global shell PATH and ignore node_modules/.binScripts like start and build are npm entry points that run package.json script commands

6. What does require/import resolve in a Node app?

Practical

Only local files, since bare package names must use an absolute pathPackages fetched over the network from the npm registry at runtimeAny file on disk, resolving bare names relative to the current directoryModules from node_modules or local files according to the module system

7. Which startup practice is safest for config?

Syntax

Provide hard-coded fallback defaults for every secret so the app always bootsLog all env vars at boot so missing ones are easy to spot in productionFail fast if required env vars are missing before listening on a portRetry reading a missing variable a few times before starting the server

8. What is node_modules?

Logic

A shared cache of every package version npm has downloaded on the machineThe list of built-in Node core modules like fs and httpA folder you edit directly to patch dependency source before publishingThe install tree of packages declared in package.json lockfiles

9. Which statement about CommonJS vs ESM is accurate for Node courses?

Concept

CommonJS uses import/export while ESM uses require and module.exportsESM modules load synchronously exactly like require doesProjects choose a module format; imports/exports must match that formatA single file may freely mix top-level require and import statements

10. Why pin versions with a lockfile?

Practical

So every environment installs the same dependency treeSo npm always installs the latest compatible minor and patch releasesSo package.json version ranges become unnecessary and can be removedSo the same lockfile also pins the Node.js runtime version

11. Given this package.json, which command runs the compiled production server?

Conceptintermediate

{
  "scripts": {
    "start": "node dist/main.js",
    "start:dev": "nest start --watch",
    "build": "nest build"
  }
}

Run npm run start:dev because it is the production entry pointRun npm run build, then npm start, which executes dist/main.jsRun npm run build alone because it also starts the server after compilingRun npm start directly, since it compiles the TypeScript on the fly before serving

12. This startup config reads a port from the environment. What is the bug?

Syntaxadvanced

const port = process.env.PORT;
app.listen(port + 1);

app.listen only accepts a numeric literal, so a variable port throws at runtimeprocess.env.PORT is a string, so port + 1 concatenates (e.g. "30001") instead of addingprocess.env.PORT is undefined here, so port + 1 evaluates to NaNNode coerces the string in arithmetic, so it correctly binds one port higher

13. Where does Node resolve each require?

Practicalintermediate

const util = require('./util');
const lodash = require('lodash');

Both from node_modules, since require always searches package folders./util from a local file; lodash from node_modulesBoth from local files, treating lodash as ./lodash beside the file./util from node_modules and lodash from a local file

14. Why prefer npm ci over npm install in CI?

Logicadvanced

# CI pipeline step
npm install

npm ci updates the lockfile to the newest matching versions during installnpm ci skips cleaning node_modules so repeat installs run fasternpm ci reads package.json ranges and ignores the lockfile for flexibilitynpm ci installs exactly from the lockfile for reproducible builds

15. Why might this line fail at runtime in a plain CommonJS Node project?

Conceptintermediate

// package.json has no "type": "module"
import express from 'express';

express has no default export, so only named imports work in CommonJSimport statements must appear after all require calls in the fileWithout ESM configured, import syntax is not supported; use require or set type: moduleNode needs a .mjs extension for every file that imports a package

Checking your session…