Master Node.js.
Interview-ready.

// math.mjs — ES Module export
export function add(a, b) { return a + b; }
export const PI = 3.14159;

// Named default export
export default { add, PI };

// app.mjs — ES Module import
import { add } from "./math.mjs";       // named
import math from "./math.mjs";           // default
import * as all from "./math.mjs";      // namespace
import { createServer } from "node:http"; // built-in (node: prefix)

// Top-level await — only available in ESM!
const data = await fetch("https://api.example.com/data");

// package.json — enable ESM project-wide
// { "type": "module" }

// Dynamic import() — works in both CJS and ESM
// Use when you need to load a module conditionally
async function loadPlugin(name) {
  const plugin = await import(`./plugins/${name}.mjs`);
  return plugin.default;
}

// In CJS — load an ES module this way:
// const { add } = await import('./math.mjs'); ✅
// const { add } = require('./math.mjs');      ❌ throws!

// Real use case: lazy load heavy libraries
app.get("/pdf", async (req, res) => {
  const { generatePDF } = await import("./pdf-generator.mjs");
  res.send(await generatePDF(req.body));
});

// ❌ BLOCKING — never do this in production
app.get("/slow", (req, res) => {
  // This blocks the ENTIRE event loop for all users!
  const start = Date.now();
  while (Date.now() - start < 2000) {} // 2 second CPU burn
  res.end("done");
});

// ✅ Non-blocking — offload CPU work to Worker Thread
const { Worker } = require("worker_threads");
app.get("/fast", (req, res) => {
  const worker = new Worker("./heavy-task.js");
  worker.on("message", result => res.json(result));
});

// ✅ fs.readFile is async — doesn't block
app.get("/file", async (req, res) => {
  const data = await fs.readFile("./data.json", "utf-8");
  // ^^ handed to libuv thread pool, event loop is FREE
  res.json(JSON.parse(data));
});

// setImmediate vs setTimeout(fn, 0) — the classic interview trick

// Outside of I/O context: order is NON-DETERMINISTIC
setTimeout(() => console.log("timeout"), 0);
setImmediate(() => console.log("immediate"));
// Could print either order — depends on system timer precision

// Inside an I/O callback: setImmediate ALWAYS wins
fs.readFile("file.txt", () => {
  setTimeout(() => console.log("timeout"), 0);
  setImmediate(() => console.log("immediate")); // ← always first
  // Why: After I/O callback, we're in "poll" phase.
  // Next phase is "check" (setImmediate), THEN loop back to "timers"
});

// process.nextTick vs setImmediate: choose carefully
setImmediate(() => console.log("after I/O cycle"));
process.nextTick(() => console.log("before I/O cycle")); // ← runs first

// ✅ Promises — flat chaining
getUser(userId)
  .then(user => getPosts(user.id))
  .then(posts => getComments(posts[0].id))
  .then(comments => saveReport(comments))
  .then(result => console.log("Done:", result))
  .catch(err => handleError(err)); // ONE error handler for all

// Creating a Promise from scratch
function delay(ms) {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, ms);
    // Call reject(err) to fail the promise
  });
}

// Promisify a callback-based function
const { promisify } = require("util");
const readFile = promisify(fs.readFile);
const content = await readFile("file.txt", "utf-8");

// ✅ async/await — reads like synchronous code
async function loadDashboard(userId) {
  try {
    const user     = await getUser(userId);
    const posts    = await getPosts(user.id);
    const comments = await getComments(posts[0].id);
    const result   = await saveReport({ user, posts, comments });
    return result;
  } catch (err) {
    // Catches ALL errors from any await above
    console.error("Dashboard load failed:", err.message);
    throw err; // Re-throw if caller needs to know
  }
}

// Common mistake: forgetting await → no error catching!
async function bad() {
  const data = fetchUser(); // ← MISSING await! data = Promise, not value
}

// Sequential (slow) — each awaits the previous
const user    = await getUser(id);     // 100ms
const profile = await getProfile(id); // 100ms
const posts   = await getPosts(id);   // 100ms
// Total: ~300ms

// ✅ Parallel (fast) — Promise.all starts all at once
const [user, profile, posts] = await Promise.all([
  getUser(id),
  getProfile(id),
  getPosts(id),
]);
// Total: ~100ms (limited by slowest)

// Promise.allSettled — don't fail if one rejects
const results = await Promise.allSettled([fetchA(), fetchB()]);
results.forEach(r => {
  if (r.status === "fulfilled") use(r.value);
  else logError(r.reason);
});

// Promise.race — first to resolve/reject wins
const data = await Promise.race([fetch(url), timeout(5000)]);