Node.js server — http module, event loop আর async I/O

১ · Server-এ JavaScript চালানো মানে কী

ধরুন “বাজারঘর”-এর React পাতা থেকে একজন ক্রেতা পণ্যের তালিকা চাইলেন। পর্ব ১৯-এ TanStack Query দিয়ে সেই ডেটা আনার দিকটি দেখেছেন। কিন্তু উত্তরটি দিচ্ছে কে? দূরের কোনো কম্পিউটারে একটি প্রোগ্রাম চলছে, যে একটি নির্দিষ্ট দরজায় কান পেতে বসে আছে। এই পর্বে আমরা সেই প্রোগ্রামটি নিজের হাতে লিখব।

Browser-এর JavaScript চলে ব্যবহারকারীর ফোনে, DOM আর বোতামের মাঝে। Node.js সেই একই ভাষাকে বের করে আনে server-এ। সেখানে DOM নেই, window নেই; আছে ফাইল, network আর process. Node-এর ভেতরে দুটি বড় অংশ: V8, যা JavaScript চালায়, আর libuv, যা অপেক্ষার কাজ সামলায়। Node-এর মূল API-র পরিচয় পাবেন JavaScript কোর্সের Node.js পর্বে; এখানে আমরা শুধু server-এর দিকে তাকাব।

২ · প্রথম server — node:http, req আর res

কোনো npm package ছাড়াই শুরু করা যায়, কারণ node:http Node-এর সাথেই আসে। মূল ভাবনা একটিই: http.createServer(fn) একটি server বানায়, আর প্রতিটি request-এ fn(req, res) ডাকা হয়। server.listen(port) তাকে একটি port-এ বসায়। Port হলো একই কম্পিউটারের নম্বর দেওয়া দরজা। আপনি যে function দিলেন, সেটি একবারই লেখা হয়, কিন্তু চলে প্রতিটি request-এ।

নিচের ব্লকে একটি সত্যিকারের server চলছে, আর একই ব্লকে fetch তাকে ডাকছে। Port 0 মানে OS একটি খালি port দেবে। fetch-এর ব্যাখ্যা আছে JavaScript-এর fetch পর্বে; HTTP বার্তার গঠন দেখেছেন পর্ব ০২-এ।

const http = require("node:http");
const products = [
  { id: 1, name: "Miniket Rice 5kg", price: 420 },
  { id: 2, name: "Masur Dal 1kg", price: 160 },
];

function sendJson(res, status, data) {
  const body = JSON.stringify(data);
  res.statusCode = status;
  res.setHeader("Content-Type", "application/json; charset=utf-8");
  res.setHeader("Content-Length", Buffer.byteLength(body));
  res.setHeader("Connection", "close");
  res.end(body);
}

const server = http.createServer((req, res) => {
  console.log("server saw:", req.method, req.url);
  const { pathname } = new URL(req.url, "http://localhost");
  const m = pathname.match(/^\/api\/products\/(\d+)$/);
  if (req.method === "GET" && pathname === "/api/products") {
    return sendJson(res, 200, products);
  }
  const item = m && products.find((p) => p.id === Number(m[1]));
  if (req.method === "GET" && item) return sendJson(res, 200, item);
  sendJson(res, 404, { error: "not found" });
});

server.listen(0, "127.0.0.1", async () => {
  const base = `http://127.0.0.1:${server.address().port}`;
  for (const path of ["/api/products", "/api/products/2", "/api/products/9"]) {
    const r = await fetch(base + path);
    console.log(r.status, r.headers.get("content-length"), await r.text());
  }
  server.close();
});

একটি request ভেতরে কীভাবে এগোয়, সেটি ধাপে ধাপে দেখুন। উদাহরণটি উপরের ব্লকের GET /api/products/2.

GET /api/products/2 HTTP/1.1
host: 127.0.0.1:PORT
accept: */*
… আরও header

TCP connection গৃহীত
socket buffer-এ bytes জমা
আপনার JavaScript চলছে না, অপেক্ষাও করছে না

OS: “এই socket-এ পড়ার মতো ডেটা আছে”
libuv: socket-এর callback চালানোর পালা
JavaScript ব্যস্ত থাকলে এই ধাপই পিছিয়ে যায়

req.method  = "GET"
req.url     = "/api/products/2"
req.headers = { host: "...", accept: "*/*" }

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 43
Connection: close
Date: …

{"id":2,"name":"Masur Dal 1kg","price":160}

Status আর header: কোনটি কার দায়িত্ব

Status code client-কে এক সংখ্যায় ফল জানায়। এই পর্বের API-তে আমরা ব্যবহার করব 200 (ঠিক আছে), 201 (তৈরি হলো), 400 (অনুরোধ ভুল), 404 (পাওয়া যায়নি), 405 (এই method চলবে না), 413 (body খুব বড়), 415 (ভুল ধরনের body), 422 (গঠন ঠিক, মান ভুল) আর 500 (আমাদের দোষ)। এদের নকশার যুক্তি আসবে পর্ব ৩৩-এ। Node নিজে থেকে শুধু 200 ধরে নেয়; ঠিক সংখ্যাটি বসানো আপনার কাজ।

Header-এর ক্ষেত্রে Node কিছু কাজ নিজেই করে। আপনি না দিলেও Date যোগ হয়, আর keep-alive চালু থাকে, যাতে একই TCP সংযোগে পরের request আসতে পারে। অংশ ৯-এর বাস্তব run-এ Keep-Alive: timeout=5 দেখবেন। Keep-alive-এর কারণেই শেষ request-এর পরেও সংযোগ কিছুক্ষণ খোলা থাকে। পাতার ব্লকে তাই Connection: close বসিয়েছি, যাতে server তাড়াতাড়ি বন্ধ হয়। কাজের API-তে এটি বসাবেন না, কারণ প্রতিবার নতুন সংযোগ খোলা ধীর।

৩ · Request body একটি stream — টুকরো জোড়া, সীমা আর বাংলা

Header ছোট, তাই একবারেই আসে। কিন্তু body ১০ MB-র ছবিও হতে পারে। সেটি পুরোটা memory-তে তুলে তারপর আপনাকে দিলে একশো জন ব্যবহারকারীই server-এর memory শেষ করে দিতে পারেন। তাই Node body দেয় stream হিসেবে: req নিজেই একটি Readable stream, যার ডেটা আসে Buffer-এর টুকরো হয়ে। Express-এ যে req.body পাবেন, সেটি কেউ এই টুকরোগুলো জোড়া দিয়ে বানিয়েছে। পর্ব ২৬-এ দেখবেন সেই কাজ করে একটি middleware.

const http = require("node:http");
const LIMIT = 200;                       // সর্বোচ্চ bytes

async function readJson(req) {
  const parts = []; let size = 0, chunks = 0;
  for await (const chunk of req) {       // req একটি readable stream
    size += chunk.length; chunks += 1;
    if (size > LIMIT) throw Object.assign(new Error("too big"), { status: 413 });
    parts.push(chunk);
  }
  console.log(`  body: ${chunks} chunk, ${size} bytes`);
  return JSON.parse(Buffer.concat(parts).toString("utf8"));
}
function send(res, status, data) {
  res.writeHead(status, { "Content-Type": "application/json", Connection: "close" });
  res.end(JSON.stringify(data));
}
const server = http.createServer(async (req, res) => {
  try {
    const p = await readJson(req);
    send(res, 201, { id: 2, name: p.name, price: p.price });
  } catch (e) {
    if (e instanceof SyntaxError) return send(res, 400, { error: "invalid JSON" });
    send(res, e.status ?? 500, { error: e.status ? e.message : "server error" });
  }
});

server.listen(0, "127.0.0.1", async () => {
  const url = `http://127.0.0.1:${server.address().port}/api/products`;
  for (const body of ['{"name":"Soybean Oil 1L","price":190}', "{bad json", "x".repeat(300)]) {
    const r = await fetch(url, { method: "POST", body });
    console.log(r.status, await r.text());
  }
  server.close();
});

body += chunk : চ���ল
Buffer.concat : চাল

সীমা কেন ঐচ্ছিক নয়? Body-র সীমা না থাকলে একজন আক্রমণকারী কয়েক GB পাঠিয়ে memory শেষ করতে পারেন। Node এর কিছু অংশ নিজে সামলায়: header-এর মোট সীমা ডিফল্টে 16 KiB, পুরো request-এর সময়সীমা ডিফল্টে ৩০০ সেকেন্ড। কিন্তু body-র আকারের কোনো ডিফল্ট সীমা node:http-এ নেই। নিরাপত্তার বিস্তার আছে API security পর্বে। একটি বড় ফাইল জমা নেওয়ার কৌশল আসবে পর্ব ৩০-এ।

৪ · হাতে routing — কোথায় ব্যথা শুরু হয়

ওপরের প্রথম ব্লকেই আপনি একটি router লিখেছেন: কয়েকটি if, যা method আর path দেখে ঠিক করে কোন কোড চলবে। দুটি route-এ এটি চমৎকার। কিন্তু “বাজারঘর”-এ শিগগিরই পণ্য, অর্ডার, কার্ট, ব্যবহারকারী, রিভিউ মিলিয়ে ৪০টি route হবে। তখন প্রতিটি নতুন route-এর সাথে নিচের কাজগুলো হাতে করতে হয়:

শেষ সারিটি শুধু বিরক্তিকর নয়, বিপজ্জনকও। async handler-এর ভেতরে কোনো ভুল ধরা না পড়লে promise reject হয়, আর Node ডিফল্টে সেই অবস্থায় পুরো process বন্ধ করে দেয়। একটি খারাপ request-এ JSON.parse ব্যর্থ করিয়ে আমরা এটি মেপে দেখেছি:

$ node crash.js
SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2)
Node.js v24.15.0
$ echo $?
1

সত্যিকারের run · Node 24.15.0 · stack trace বাদ দেওয়া

অর্থাৎ একজনের ভুল request-এ সবার সেবা বন্ধ। তাই ওপরের ব্লকে try/catch ছিল। Framework-এর আসল মূল্য এখানেই: Express কোনো জাদু নয়, এই পুনরাবৃত্তিগুলোর একটি ভালোভাবে পরীক্ষিত সমাধান। তবে আগে হাতে করে দেখা জরুরি, নইলে framework ভুল করলে কারণ খুঁজে পাবেন না। Express-এর সাথে এই একই কোডের তুলনা আছে JavaScript কোর্সের Express পর্বে, আর এই কোর্সে পর্ব ২৫-এ আমরা “বাজারঘর”-কে সেখানে নিয়ে যাব।

৫ · Event loop — একটি ঘুরে কী কী হয়

Request এলে কে আপনার function ডাকে? Event loop. এটি একটি সাধারণ লুপ, যা বারবার জিজ্ঞেস করে: “কোন কাজ তৈরি?” তারপর একে একে তাদের callback চালায়। মূল ধারণা, microtask আর ক্রমের ধাঁধা বিস্তারিত আছে JavaScript-এর event loop পর্বে; Promise আর async/await-এর ভাষা শিখতে দেখুন Promises আর async/await. এখানে শুধু একটি server-এর চোখে দেখি।

আর দুটি ছোট লাইন আছে, যা কোনো phase নয়। প্রতিটি callback শেষ হলে পরের callback-এর আগে Node খালি করে process.nextTick-এর queue, তারপর Promise-এর microtask queue. তাই await-এর পরের কোড খুব তাড়াতাড়ি চলে।

একটি request handler হলো poll phase-এর callback, অর্থাৎ I/O-এর ভেতরেই। তাই নিচের ক্রমটি নিশ্চিত।

const http = require("node:http");
const log = (m) => console.log(m);

const server = http.createServer((req, res) => {
  log("1 handler starts (poll phase)");
  setTimeout(() => log("6 setTimeout 0"), 0);
  setImmediate(() => log("5 setImmediate (check phase)"));
  Promise.resolve().then(() => log("4 promise microtask"));
  process.nextTick(() => log("3 nextTick"));
  res.setHeader("Connection", "close");
  res.end("ok");
  log("2 handler ends");
});

server.listen(0, "127.0.0.1", async () => {
  const r = await fetch(`http://127.0.0.1:${server.address().port}/`);
  await r.text();
  server.close(() => log("7 server closed"));
});

শেষ ধাপটিই বলে দেয় server কেন চলতেই থাকে। Loop ততক্ষণ ঘোরে, যতক্ষণ কিছু একটির অপেক্ষা বাকি। একটি খোলা listening socket মানে “অপেক্ষা বাকি”। server.close() না ডাকলে পাতার ব্লক কখনো শেষ হতো না।

৬ · Non-blocking I/O আর thread pool — অপেক্ষা কে করে

“Node single-threaded” কথাটি অর্ধেক সত্য। আপনার JavaScript একটি thread-এ চলে, কিন্তু Node process-এ আরও thread থাকে। Non-blocking I/O মানে “কাজটি শুরু করে দিলাম, শেষ হলে খবর পাব”। কিন্তু সেই “জানানো” দুইভাবে হয়।

Thread pool মাত্র ৪ জনের। পঞ্চম কাজটি লাইনে দাঁড়ায়। এটি মেপে দেখুন: ৮টি crypto.pbkdf2 একসাথে দেওয়া হলো, প্রতিটি 10 লাখ রাউন্ডের, আর প্রতিটি শেষ হওয়ার সময় (ms) ছাপা হলো।

$ UV_THREADPOOL_SIZE=4 node pool.js
123 125 198 234 339 356 371 407
$ UV_THREADPOOL_SIZE=8 node pool.js
133 144 148 185 215 216 249 274

সত্যিকারের run · Node 24.15.0 · একটি local machine-এ একবারের মাপ, অন্য কাজও চলছিল; সাধারণ ফল নয়

প্রথম সারিতে ৪টি কাজ শেষ হয় ২৩৪ ms-এর মধ্যে, বাকি ৪টি পিছনের দলে, ৪০৭ ms পর্যন্ত। থ্রেড বাড়িয়ে ৮ করলে সব শেষ হয় ২৭৪ ms-এ। আদর্শ হিসাবে একটি কাজ ১২০ ms ধরলে ৪ thread-এ দুই দফা, মানে ২৪০ ms হওয়ার কথা; বাস্তবে বেশি লেগেছে, কারণ CPU core অন্য কাজের সাথে ভাগ হয়। UV_THREADPOOL_SIZE বসাতে হয় process চালু করার সময়, কোডের ভেতর থেকে process.env-এ বসালে কাজ করবে, এমন নিশ্চয়তা Node দেয় না।

৭ · যা loop আটকে দেয় — আসল মাপ

এবার আসল বিপদ। Blocking call মানে JavaScript-এর thread নিজেই কাজ করছে বা অপেক্ষা করছে। সেই সময় loop ঘুরতে পারে না, তাই অন্য কোনো request-এর callback চলে না। মনে রাখবেন, একটি process-এর সব ব্যবহারকারী সেই একই thread ভাগ করছেন।

const http = require("node:http");
const { pbkdf2, pbkdf2Sync } = require("node:crypto");
const ROUNDS = 400_000;
const hash = (cb) => pbkdf2("pass", "salt", ROUNDS, 32, "sha256", cb);

const server = http.createServer((req, res) => {
  res.setHeader("Connection", "close");
  if (req.url === "/ping") return res.end("pong");
  if (req.url === "/sync") {
    pbkdf2Sync("pass", "salt", ROUNDS, 32, "sha256");   // loop আটকে
    return res.end("done");
  }
  hash(() => res.end("done"));                          // thread pool-এ
});

async function trial(base, path) {
  const t0 = performance.now();
  const ms = () => Math.round(performance.now() - t0);
  let slow, ping;
  const a = fetch(base + path).then((r) => r.text()).then(() => (slow = ms()));
  await new Promise((r) => setTimeout(r, 5));           // ৫ ms পরে দ্বিতীয় জন
  const b = fetch(base + "/ping").then((r) => r.text()).then(() => (ping = ms()));
  await Promise.all([a, b]);
  console.log(`${path.padEnd(6)} hash=${slow} ms, ping=${ping} ms`);
}

server.listen(0, "127.0.0.1", async () => {
  const base = `http://127.0.0.1:${server.address().port}`;
  await (await fetch(base + "/ping")).text();           // fetch গরম করা
  await trial(base, "/sync");
  await trial(base, "/async");
  server.close();
});

কোন কাজ কতটা আটকায়: মাপা সংখ্যা

আলাদা process থেকে client একটি ধীর request পাঠাল, আর সেটি চলার সময় প্রতি ১০ ms-এ /ping করল। খালি অবস্থায় ping-এর median ছিল ০.৯ ms. সবচেয়ে ধীর ping দেখায় loop কতটা আটকেছিল। প্রতিটি সারি ৫ বারের median.

সত্যিকারের run · Node 24.15.0 · একটি local machine, SSD, ফাইল OS cache-এ · সাধারণ benchmark নয়

তিনটি জিনিস লক্ষ করুন। প্রথমত, JSON.parse আর JSON.stringify async নয়; এদের async রূপও নেই। বড় তালিকা পাঠানো তাই নিজেই একটি blocking কাজ, আর সেজন্যই পর্ব ৩৪-এ pagination আসবে। দ্বিতীয়ত, readFileSync এখানে দ্রুত দেখাচ্ছে শুধু ফাইলটি cache-এ ছিল বলে। ধীর disk-এ সংখ্যাটি অনেক বড় হতে পারে। তৃতীয়ত, Worker-এ মোট সময় বেশি লেগেছে; নতুন Worker চালু করারও খরচ আছে। তবু ping প্রায় অক্ষত।

Throughput-এর হিসাব: ১০ ms কত বড়

একটি উত্তরের সময় নয়, পুরো server-এর ক্ষমতা মাপা যাক। autocannon 8.0.0 দিয়ে ৫০টি সংযোগ ৫ সেকেন্ড চাপ দিল, তিনটি আলাদা route-এ।

সত্যিকারের run · autocannon 8.0.0, Node 24.15.0 · একটি local machine, client একই কম্পিউটারে · একবারের মাপ

সংখ্যাগুলো হিসাব দিয়ে মিলিয়ে নেওয়া যায়। Latency আর throughput-এর সম্পর্ক এখানে স্পষ্ট:

• Sync CPU: এক thread এক সেকেন্ডে 1000 ms ÷ 10 ms = ১০০টি কাজ করতে পারে। মাপা হয়েছে ৯৮.৮. একটি request-কে আগের ৫০ জনের লাইনে দাঁড়াতে হয়: 50 × 10 ms = 500 ms. মাপা p50 হলো 506 ms.
• Async অপেক্ষা: ৫০ জন একসাথে অপেক্ষা করতে পারে। এই run-এ অপেক্ষা হয়েছে p50 15 ms, তাই 50 ÷ 0.015 s ≈ ৩,৩৩৩ request/s. মাপা ২,৮৬১, কারণ বাকি CPU খরচও আছে।
• শিক্ষা: একই “১০ ms” অপেক্ষা হলে ক্ষমতা নামে ২৭ গুণ, CPU হলে প্রায় ৭৭৫ গুণ।

আটকে গেলে কী করবেন

• Async রূপ নিন: request-এর পথে readFileSync, pbkdf2Sync, execSync-এর মতো Sync নাম এড়িয়ে চলুন। Server চালুর সময় একবার config পড়তে sync ব্যবহার ঠিক আছে।
• কম ডেটা: ৩ লাখ সারি না পাঠিয়ে pagination, আর বড় export হলে stream.
• কাজ টুকরো করুন: লম্বা লুপকে ছোট ভাগে করে মাঝে setImmediate দিন, যাতে অন্যরা সুযোগ পায়।
• সরিয়ে দিন: ছবি বানানো বা রিপোর্টের মতো ভারী কাজ worker_threads বা আলাদা background job-এ (পর্ব ৬২)। Regex-এও সাবধান: খারাপ regex একা loop আটকাতে পারে, যাকে বলে ReDoS.

৮ · Concurrency বনাম parallelism

দুটি শব্দ প্রায়ই গুলিয়ে যায়। Concurrency মানে একই সময়কালে অনেক কাজের দায়িত্ব নেওয়া, যদিও এক মুহূর্তে একটিই হচ্ছে। Parallelism মানে একই মুহূর্তে সত্যিই একাধিক কাজ চলা, যার জন্য একাধিক CPU core লাগে। চায়ের দোকানের একজন দোকানি চুলায় চা বসিয়ে বিস্কুট দেন, হিসাব লেখেন: এটি concurrency. দুজন দোকানি দুই চুলায় একসাথে চা বানান: এটি parallelism.

নিচের run-এ ২০টি request, প্রতিটিতে ১০০ ms-এর নকল database অপেক্ষা। Node-এর thread একটিই।

$ node conc.js
one by one : 2183 ms
all at once: 127 ms

সত্যিকারের run · Node 24.15.0 · একটি local machine-এ একবারের মাপ

২০ × 100 ms = ২ সেকেন্ড লাগত লাইনে দাঁড়ালে, কিন্তু একসাথে দিলে লাগল ১২৭ ms. এটি parallelism নয়, কারণ thread একটিই; অপেক্ষাগুলো একে অপরের ওপর পড়েছে। ঠিক এই কারণেই অপেক্ষার কাজে Node ভালো, আর ওপরের CPU কাজে নয়। এই মডেলের একটি সুবিধাও আছে: দুটি await-এর মাঝের কোড কেউ থামায় না, তাই একটি সাধারণ variable নিয়ে thread-জনিত গোলমাল হয় না। তবে await-এর দুই পাশে race condition ঠিকই হতে পারে। মডিউল ৬-এর পর্ব ৪৩-এ স্টকের হিসাবে সেটি দেখবেন।

৯ · “বাজারঘর”-এর products API — framework ছাড়া

এবার সব জোড়া দিই। আগে তিনটি ছোট প্রস্তুতি।

Version: পর্ব ০৫-এ দেখেছেন, কাজের project-এ LTS নিন, আর .nvmrc-এ version লিখে রাখুন। এখানে package.json-এর engines সেটিই জানায়। এই পর্বের project চলেছে Node 24.15.0-তে, আর পাতার ব্লকগুলো চলে Node 20 version-এ।

ES module: Node-এ দুটি module ব্যবস্থা আছে। পুরোনো CommonJS (require), যা পাতার ব্লকগুলোতে ব্যবহার হয়েছে, আর আধুনিক ES module (import). package.json-এ "type": "module" দিলে .js ফাইল ES module হয়। ভাষার নিয়ম আছে Modules পর্বে; Node-এ তিনটি পার্থক্য রোজ চোখে পড়ে:

ES module-এর মূল স্তরে top-level await চলে, যা server চালুর আগে config পড়তে কাজে লাগে। একটি সূক্ষ্মতা: মূল স্তরে ক্রম উল্টে যায়। .mjs ফাইলে সত্যিকারের run-এ এসেছে sync promise nextTick, কারণ module-এর কোড নিজেই promise-এর কাজ হিসেবে চলে। Handler-এর ভেতরে আগের নিয়মই থাকে।

Watch mode: node --watch src/index.js ফাইল বদলালে process আবার চালু করে। আলাদা package লাগে না; v22.0.0 আর v20.13.0 থেকে এটি stable. এটি browser-এর HMR নয়: পুরো process নতুন করে শুরু হয়, তাই memory-তে থাকা ডেটা মুছে যায়। পর্ব ০৫-এর কাঠামোয় server/src/index.ts ছিল; এখানে Node-কে সরাসরি দেখার জন্য সাধারণ .js রাখা হয়েছে।

ফাইল চারটি: products.js (memory-তে ডেটা), http-utils.js, routes.js, index.js. পর্ব ০৪-এর স্তরের চিন্তা এখানে ছোট আকারে; পর্ব ২৯-এ সেটি পুরো গঠন পাবে। if-এর সারির বদলে route-এর একটি তালিকা রাখা হয়েছে, যাতে 405 আর Allow এক জায়গায় হয়।

import http from "node:http";
import { routes } from "./routes.js";
import { HttpError, sendJson } from "./http-utils.js";

const PORT = Number(process.env.PORT ?? 3000);

const server = http.createServer(async (req, res) => {
  const started = performance.now();
  const url = new URL(req.url, "http://localhost");
  try {
    const route = routes.find((r) => r.pattern.test(url.pathname));
    if (!route) throw new HttpError(404, "route not found");

    const handler = route.methods[req.method];
    if (!handler) {
      res.setHeader("Allow", Object.keys(route.methods).join(", "));
      throw new HttpError(405, "method not allowed");
    }
    const params = url.pathname.match(route.pattern).slice(1);
    await handler(req, res, { url, params });
  } catch (err) {
    if (!(err instanceof HttpError)) console.error(err);
    const status = err instanceof HttpError ? err.status : 500;
    sendJson(res, status, {
      error: status === 500 ? "internal server error" : err.message,
    });
  } finally {
    const ms = (performance.now() - started).toFixed(1);
    console.log(`${req.method} ${url.pathname} ${res.statusCode} ${ms}ms`);
  }
});

server.listen(PORT, "127.0.0.1", () => {
  console.log(`bazarghar API: http://127.0.0.1:${PORT}`);
});

import { addProduct, findProduct, listProducts } from "./products.js";
import { HttpError, readJson, sendJson } from "./http-utils.js";

function getList(req, res, ctx) {
  sendJson(res, 200, listProducts(ctx.url.searchParams.get("category")));
}

function getOne(req, res, ctx) {
  const product = findProduct(Number(ctx.params[0]));
  if (!product) throw new HttpError(404, "product not found");
  sendJson(res, 200, product);
}

async function create(req, res) {
  const { name, category, price } = await readJson(req);
  if (typeof name !== "string" || !name.trim() || !Number.isInteger(price) || price < 0) {
    throw new HttpError(422, "name and a non-negative integer price are required");
  }
  sendJson(res, 201, addProduct({ name: name.trim(), category, price }));
}

// হাতে লেখা route table: pattern, তারপর method অনুযায়ী handler
export const routes = [
  { pattern: /^\/api\/products$/, methods: { GET: getList, POST: create } },
  { pattern: /^\/api\/products\/(\d+)$/, methods: { GET: getOne } },
];

export class HttpError extends Error {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

export function sendJson(res, status, data) {
  const body = JSON.stringify(data);
  res.writeHead(status, {
    "Content-Type": "application/json; charset=utf-8",
    "Content-Length": Buffer.byteLength(body),
  });
  res.end(body);
}

export async function readJson(req, limit = 10_000) {
  const type = req.headers["content-type"] ?? "";
  if (!type.startsWith("application/json")) {
    throw new HttpError(415, "Content-Type must be application/json");
  }
  const parts = [];
  let size = 0;
  for await (const chunk of req) {
    size += chunk.length;
    if (size > limit) throw new HttpError(413, "body too large");
    parts.push(chunk);
  }
  try {
    return JSON.parse(Buffer.concat(parts).toString("utf8"));
  } catch {
    throw new HttpError(400, "invalid JSON");
  }
}

// সাময়িক ডেটা: memory-তে, server বন্ধ হলে মুছে যায়। Database আসবে মডিউল ৬-এ।
const products = [
  { id: 1, name: "মিনিকেট চাল ৫ কেজি", category: "rice", price: 420 },
  { id: 2, name: "মসুর ডাল ১ কেজি", category: "dal", price: 160 },
  { id: 3, name: "সয়াবিন তেল ১ লিটার", category: "oil", price: 190 },
];
let nextId = 4;

export function listProducts(category) {
  return category ? products.filter((p) => p.category === category) : products;
}

export function findProduct(id) {
  return products.find((p) => p.id === id);
}

export function addProduct({ name, category, price }) {
  const item = { id: nextId++, name, category, price };
  products.push(item);
  return item;
}

{
  "name": "bazarghar-server",
  "private": true,
  "type": "module",
  "engines": { "node": ">=22" },
  "scripts": {
    "dev": "node --watch src/index.js",
    "start": "node src/index.js"
  }
}

এবার সত্যিকারের চালানো। এক terminal-এ server, অন্যটিতে curl.

$ cd ~/bazarghar/server
$ PORT=47833 node --watch src/index.js
bazarghar API: http://127.0.0.1:47833

$ B=http://127.0.0.1:47833/api/products

$ curl -i $B/1
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 96
Date: Sun, 01 Nov 2026 16:34:33 GMT
Connection: keep-alive
Keep-Alive: timeout=5

{"id":1,"name":"মিনিকেট চাল ৫ কেজি","category":"rice","price":420}

$ curl "$B?category=dal"
[{"id":2,"name":"মসুর ডাল ১ কেজি","category":"dal","price":160}]

$ curl -i -X POST $B -H "Content-Type: application/json" \
    -d '{"name":"Lal Chini 1kg","category":"sugar","price":150}'
HTTP/1.1 201 Created
…
{"id":4,"name":"Lal Chini 1kg","category":"sugar","price":150}

$ curl -i -X POST $B -H "Content-Type: application/json" -d '{bad json'
HTTP/1.1 400 Bad Request
…
{"error":"invalid JSON"}

$ curl -i -X POST $B -H "Content-Type: application/json" -d '{"name":"x","price":-5}'
HTTP/1.1 422 Unprocessable Entity
…
{"error":"name and a non-negative integer price are required"}

$ curl -X POST $B -d 'name=x'
{"error":"Content-Type must be application/json"}

$ curl -i -X DELETE $B/1
HTTP/1.1 405 Method Not Allowed
Allow: GET
…
{"error":"method not allowed"}

$ curl -i $B/999
HTTP/1.1 404 Not Found
…
{"error":"product not found"}

$ curl -i -X POST $B -H "Content-Type: application/json" --data-binary @big.json
HTTP/1.1 413 Payload Too Large
…
{"error":"body too large"}

সত্যিকারের run · Node 24.15.0, curl · পথ আর host নিরপেক্ষ করা হয়েছে · “…” মানে একই header বাদ

Server-এর terminal-এ নিজের log, আর একটি ফাইল বদলাতেই watch mode-এর কাজ:

GET /api/products/1 200 2.4ms
GET /api/products 200 0.5ms
POST /api/products 201 1.0ms
POST /api/products 400 0.4ms
POST /api/products 422 0.3ms
POST /api/products 415 0.2ms
DELETE /api/products/1 405 0.3ms
GET /api/products/999 404 0.2ms
GET /api/nothing 404 0.1ms
POST /api/products 413 0.6ms
Restarting 'src/index.js'
bazarghar API: http://127.0.0.1:47833

সত্যিকারের run · Node 24.15.0

প্রথম উত্তরে Content-Length: 96 দেখুন: JSON-এ অক্ষর কম, কিন্তু bytes বেশি, কারণ বাংলা। Restart-এর পরে নতুন পণ্যটি হারিয়ে যাবে; ডেটা memory-তে ছিল। Database আসবে মডিউল ৬-এ। আর একটি পরিচিত ভুল: একই port-এ দ্বিতীয় copy চালালে Node এভাবে থামে:

Error: listen EADDRINUSE: address already in use 127.0.0.1:47833
  …
  code: 'EADDRINUSE',

সত্যিকারের run · Node 24.15.0

আগের process বন্ধ করুন বা অন্য port দিন। API-টি চলছে, তবে এখন কত লাইন লেগেছে দেখুন, আর ভাবুন ৪০টি route, login আর যাচাই যোগ হলে কী হবে। এই চিন্তাটি নিয়েই পর্ব ২৫-এ যাবেন।

১০ · AI-এর যুগে — AI-এর লেখা Node server যাচাই

AI খুব সহজে “চলছে” এমন server লিখে দেয়। ঝামেলা হয় যা পরীক্ষায় ধরা পড়ে না, সেখানে: ছোট ইংরেজি ডেটায় সব ঠিক, ভিড়ে আর বাংলায় ভেঙে পড়ে। এই পর্বের মাপগুলোই আপনার যাচাইয়ের অস্ত্র।

AI-এর লেখা server হাতে পেলে — চেকলিস্ট

• নিজের Node version-এ চালিয়েছি, আর API-গুলো সেই version-এর docs-এ মিলিয়েছি
• ভাঙা JSON, খুব বড় body আর ভুল Content-Type পাঠিয়ে দেখেছি process বেঁচে আছে
• বাংলা নাম পাঠিয়ে ফেরত পড়েছি, আর Content-Length bytes-এ আছে দেখেছি
• Sync শব্দ খুঁজেছি, আর ভিড়ের মধ্যে একটি ছোট route-এর latency মেপেছি
• Error উত্তরে stack trace বা ভেতরের path যাচ্ছে না
• Diff পড়ে নতুন প্রতিটি dependency-র কারণ জেনেছি, আর একটি test লিখেছি