Node.js Cheatsheet

CommonJS require

const fs = require("fs");
const { join } = require("path");
const myModule = require("./my-module");

CommonJS export

module.exports = { hello, goodbye };
// or
module.exports = function hello() { ... };

ESM import (package.json: "type":"module")

import fs from "fs";
import { join } from "path";
import myModule from "./my-module.js";

ESM export

export function hello() { ... }
export default class App { ... }

__dirname / __filename in ESM

import { fileURLToPath } from "url";
import { dirname } from "path";
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

Read file (async)

import { readFile, writeFile } from "fs/promises";

const content = await readFile("file.txt", "utf8");

Write file

await writeFile("output.txt", "Hello!", "utf8");

Append to file

import { appendFile } from "fs/promises";
await appendFile("log.txt", "new line\n");

Check exists

import { access, constants } from "fs";
try {
  await access("file.txt", constants.F_OK);
  console.log("exists");
} catch { console.log("not found"); }

List directory

import { readdir } from "fs/promises";
const files = await readdir("./src");

Delete file

import { unlink } from "fs/promises";
await unlink("temp.txt");

Simple server

import { createServer } from "http";

const server = createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "application/json" });
  res.end(JSON.stringify({ ok: true }));
});

server.listen(3000, () => console.log("Listening on 3000"));

Read request body

let body = "";
req.on("data", chunk => body += chunk);
req.on("end", () => {
  const data = JSON.parse(body);
});

Read env vars

const port = process.env.PORT ?? 3000;
const dbUrl = process.env.DATABASE_URL;

Load .env with dotenv

import "dotenv/config"; // must be first import
// or
import dotenv from "dotenv";
dotenv.config();

process.argv

const args = process.argv.slice(2);
// node script.js foo bar → ["foo", "bar"]

process.exit

process.exit(0); // success
process.exit(1); // failure

Readable stream

import { createReadStream } from "fs";
const stream = createReadStream("large.csv", { encoding: "utf8" });
stream.on("data", chunk => process(chunk));
stream.on("end", () => console.log("done"));

Pipe streams

import { createReadStream, createWriteStream } from "fs";
const r = createReadStream("input.txt");
const w = createWriteStream("output.txt");
r.pipe(w);

pipeline (preferred)

import { pipeline } from "stream/promises";
await pipeline(
  createReadStream("input.txt"),
  createGzip(),
  createWriteStream("input.txt.gz")
);

Setup

import express from "express";
const app = express();
app.use(express.json());
app.listen(3000);

Routes

app.get("/users", async (req, res) => {
  const users = await db.getUsers();
  res.json(users);
});

app.post("/users", async (req, res) => {
  const user = await db.createUser(req.body);
  res.status(201).json(user);
});

Route params & query

app.get("/posts/:id", (req, res) => {
  const { id } = req.params;
  const { format } = req.query;
});

Middleware

function auth(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).json({ error: "Unauthorized" });
  }
  next();
}

app.use("/api", auth);

Error handler

app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: "Internal Server Error" });
});