🧰 Core Modules: fs, path & http

What Are Core Modules?

Core modules are libraries built into the Node runtime itself. They need no installation, they're maintained alongside Node, and they're tuned for its event-driven model. You pull one in by name — no package required.

// CommonJS (the classic style) — the node: prefix marks a built-in
const fs   = require('node:fs/promises');
const path = require('node:path');
const http = require('node:http');

// ES Modules (modern) — needs "type": "module" in package.json
import fs   from 'node:fs/promises';
import path from 'node:path';
import http from 'node:http';

The fs Module

The file system module reads, writes, and manages files and directories. It offers three flavours of nearly every operation — and choosing the right one matters.

Reading files

const fs = require('node:fs/promises');

// ✅ Modern promise API with async/await
async function readNotes() {
    try {
        const data = await fs.readFile('notes.txt', 'utf8');
        console.log(data);
    } catch (err) {
        console.error('Could not read file:', err.message);
    }
}
readNotes();

For very large files, don't load the whole thing into memory — stream it in chunks:

const { createReadStream } = require('node:fs');

const stream = createReadStream('huge.log', { encoding: 'utf8' });
stream.on('data',  (chunk) => console.log(`got ${chunk.length} bytes`));
stream.on('end',   () => console.log('done reading'));
stream.on('error', (err) => console.error(err));

Writing & appending

const fs = require('node:fs/promises');

async function saveLog(line) {
    // writeFile replaces the whole file...
    await fs.writeFile('output.txt', 'Hello, World!\n');
    // ...appendFile adds to the end without erasing what's there
    await fs.appendFile('app.log', `${new Date().toISOString()} — ${line}\n`);
    console.log('saved');
}
saveLog('server started');

Directory operations

const fs = require('node:fs/promises');

async function setup() {
    // recursive: true creates every missing parent, no error if it exists
    await fs.mkdir('data/cache', { recursive: true });

    // List directory contents
    const entries = await fs.readdir('data');
    console.log('contents:', entries);

    // Inspect a single entry
    const info = await fs.stat('data/cache');
    console.log('is directory?', info.isDirectory());
}
setup();

const fs = require('node:fs/promises');

async function bumpVisits() {
    let count = 0;
    try {
        count = Number(await fs.readFile('visits.txt', 'utf8'));
    } catch (err) {
        if (err.code !== 'ENOENT') throw err; // ENOENT = file not found → start at 0
    }
    count += 1;
    await fs.writeFile('visits.txt', String(count));
    return count;
}

bumpVisits().then((n) => console.log(`Visit #${n}`));

The path Module

Never build file paths by gluing strings with /. Windows uses \, Unix uses /, and hand-joining invites bugs and security holes. The path module handles all of it correctly.

const path = require('node:path');

// Join segments using the OS-correct separator
path.join(__dirname, 'public', 'css', 'app.css');
// → /home/ray/project/public/css/app.css

// Resolve to an absolute path from the current working directory
path.resolve('docs', 'guide.md');
// → /home/ray/project/docs/guide.md

path.basename('/users/docs/report.pdf');        // 'report.pdf'
path.basename('/users/docs/report.pdf', '.pdf'); // 'report'
path.dirname('/users/docs/report.pdf');         // '/users/docs'
path.extname('script.js');                       // '.js'

// Break a path into its parts
path.parse('/home/ray/docs/report.pdf');
// { root: '/', dir: '/home/ray/docs', base: 'report.pdf', ext: '.pdf', name: 'report' }

// Clean up '..' and '.' segments
path.normalize('/users/./docs/../docs/report.pdf'); // '/users/docs/report.pdf'

The http Module

This is the module that made Node famous: with a few lines you have a working web server. Every framework you'll use — Express included — is built on top of it.

A server with routing

const http = require('node:http');

const server = http.createServer((req, res) => {
    res.setHeader('Content-Type', 'application/json');

    if (req.method === 'GET' && req.url === '/') {
        res.statusCode = 200;
        res.end(JSON.stringify({ message: 'Welcome!' }));

    } else if (req.method === 'GET' && req.url === '/api/users') {
        const users = [
            { id: 1, name: 'Ada Lovelace' },
            { id: 2, name: 'Grace Hopper' },
        ];
        res.statusCode = 200;
        res.end(JSON.stringify(users));

    } else {
        res.statusCode = 404;
        res.end(JSON.stringify({ error: 'Not Found' }));
    }
});

server.listen(3000, () => {
    console.log('Server running at http://localhost:3000/');
});

Notice how quickly this if/else ladder gets tedious. Multiply it by dozens of routes and you'll understand exactly why Express exists — but it's healthy to see the raw machinery first.

Serving static files

const http = require('node:http');
const fs   = require('node:fs/promises');
const path = require('node:path');

const MIME = {
    '.html': 'text/html',
    '.css':  'text/css',
    '.js':   'text/javascript',
    '.json': 'application/json',
    '.png':  'image/png',
};

const server = http.createServer(async (req, res) => {
    // Block directory traversal by normalizing and stripping leading '..'
    const safeUrl = path.normalize(req.url).replace(/^(\.\.[/\\])+/, '');
    const filePath = path.join(__dirname, 'public', safeUrl === '/' ? 'index.html' : safeUrl);

    try {
        const content = await fs.readFile(filePath);
        const type = MIME[path.extname(filePath)] || 'application/octet-stream';
        res.writeHead(200, { 'Content-Type': type });
        res.end(content);
    } catch (err) {
        res.writeHead(err.code === 'ENOENT' ? 404 : 500);
        res.end(err.code === 'ENOENT' ? 'Not Found' : 'Server Error');
    }
});

server.listen(3000, () => console.log('http://localhost:3000/'));

Node as a client

const https = require('node:https');

https.get('https://api.github.com/users/nodejs', {
    headers: { 'User-Agent': 'node-course' }
}, (res) => {
    let data = '';
    res.on('data',  (chunk) => data += chunk);
    res.on('end',   () => console.log(JSON.parse(data).name));
}).on('error', (err) => console.error(err.message));

const res  = await fetch('https://api.github.com/users/nodejs', {
    headers: { 'User-Agent': 'node-course' }
});
const data = await res.json();
console.log(data.name);

os, events & util

os — system information

const os = require('node:os');

console.log(`Platform: ${os.platform()}`);          // 'linux' | 'darwin' | 'win32'
console.log(`CPU cores: ${os.cpus().length}`);
console.log(`Free memory: ${(os.freemem() / 1e9).toFixed(2)} GB`);
console.log(`Home dir: ${os.homedir()}`);

events — the EventEmitter

The event-driven heart of Node. Many built-ins (servers, streams) are emitters; you can build your own too.

const EventEmitter = require('node:events');

class Logger extends EventEmitter {
    log(message) {
        console.log(`LOG: ${message}`);
        this.emit('logged', { message, at: Date.now() });
    }
}

const logger = new Logger();
logger.on('logged', (data) => console.log('listener fired:', data.message));
logger.log('Hello, events!');

util — handy helpers

const util = require('node:util');
const fs   = require('node:fs');

// Turn an old callback-style function into a promise-returning one
const readFileAsync = util.promisify(fs.readFile);

const data = await readFileAsync('config.json', 'utf8');
console.log(JSON.parse(data));

Practice & Quiz

// note.js — run as:  node note.js "Buy milk"
// TODO: append the arg with a timestamp, then read & print notes.txt

// note.js
const fs = require('node:fs/promises');

async function main() {
    const note = process.argv[2];
    if (!note) {
        console.error('Usage: node note.js "your note"');
        process.exit(1);
    }
    await fs.appendFile('notes.txt', `${new Date().toISOString()} — ${note}\n`);
    const all = await fs.readFile('notes.txt', 'utf8');
    console.log('--- notes.txt ---');
    console.log(all);
}
main();

const http = require('node:http');

http.createServer((req, res) => {
    res.setHeader('Content-Type', 'application/json');
    if (req.method === 'GET' && req.url === '/api/time') {
        res.statusCode = 200;
        res.end(JSON.stringify({ now: new Date().toISOString() }));
    } else {
        res.statusCode = 404;
        res.end(JSON.stringify({ error: 'Not Found' }));
    }
}).listen(3000, () => console.log('http://localhost:3000/api/time'));

Best Practices & Pitfalls

✅ Do

• Default to fs/promises and async/await for readable async code
• Build every path with path.join / path.resolve and __dirname
• Use the node: prefix so it's obvious a module is built in
• Stream large files instead of loading them entirely into memory
• Handle errors — check err.code for expected cases like ENOENT

❌ Don't

• Use *Sync methods inside a server request handler
• Concatenate paths with + '/' +
• Trust user-supplied paths without normalizing against traversal
• Reinvent a full framework by hand — this is where Express takes over

// ❌ Dangerous — a request for /../../etc/passwd escapes your folder
const filePath = path.join(__dirname, 'public', req.url);

// ✅ Normalize and strip leading '..' segments first
const safe = path.normalize(req.url).replace(/^(\.\.[/\\])+/, '');
const filePath = path.join(__dirname, 'public', safe);

Summary

📚 Additional Resources

• Node.js — File System (fs) documentation
• Node.js — Path documentation
• Node.js — HTTP documentation
• Node.js — Events (EventEmitter) documentation

🚀 What's Next?

You've felt the friction of hand-rolling routes and MIME types with the raw http module. Next lesson we bring in Express — the framework that turns all that boilerplate into a few expressive lines and kicks off building real APIs.