الإقليم ٢ — Node من جذور C: كيف لا ينام خيطٌ واحد

النبذة

في الإقليم ١ تركنا لغزاً معلّقاً: server.ts ينادي app.listen(PORT, () => {...})، ثم لا ينتهي البرنامج — يظلّ يستقبل طلباتٍ بلا حدّ، بخيطٍ واحد، بلا while(1) ظاهرة، وawait فيه "ينتظر" دون أن يجمّد شيئاً. لو حاولتَ شرح هذا بعقلية C البحتة لانهار التفسير. لكن المفاجأة أنك تملك المفتاح أصلاً: Node ليس إلا epoll — الذي بنيتَ عليه فهمك للشبكات في C — وقد لُفّ بلغةٍ كانت مصمَّمةً مسبقاً لتلبسه. من يفهم هذا الإقليم، يتوقّف عن رؤية الـ backend سحراً.

هذا أعمق إقليمٍ مفاهيميٍّ في المنهج. خذ وقتك. كل ما بعده يقف عليه.

اللغز المستفزّ

c
while (1) {
    int client = accept(server_fd, ...);   // انتظر اتصالاً
    char buf[1024];
    read(client, buf, sizeof buf);          // ← اقرأ طلبه
    process_and_respond(client, buf);
    close(client);
}

ليش: ثلاثة طرقٍ للتزامن، وأيّها اختارت Node ولماذا

الطريق ١ — الحجب + خيطٌ لكل عميل (الذي رفضناه)

بسيطٌ ذهنياً، لكنه ينهار عند الحجم (ذاكرة + context switching). يصلح لمئات الاتصالات، لا لعشرات الآلاف. هذا طريق خوادمَ كلاسيكية (نمط أباتشي القديم).

الطريق ٢ — non-blocking + busy polling (نصفُ حلّ)

اجعل الـ socket غير حاجب: fcntl(fd, F_SETFL, O_NONBLOCK). الآن read() لا يحجب — إن لم تكن هناك بايتات، يرجع فوراً بـ -1 وerrno == EAGAIN ("لا شيء الآن، عُد لاحقاً"). فتقدر تمرّ على كل العملاء بخيطٍ واحد:

c
for (each client fd) {
    n = read(fd, buf, size);
    if (n > 0) handle(fd, buf);
    else if (errno == EAGAIN) continue;   // ليس جاهزاً، التالي
}
// كرّر للأبد...

حللنا الحجب! لكن خلقنا داءً جديداً: هذه الحلقة تدور بلا توقّفٍ تستنزف الـ CPU بنسبة ١٠٠٪ حتى لو لم يكن أحدٌ جاهزاً، تسأل آلافَ الـ fds "جاهز؟ جاهز؟" بلا راحة. هدرٌ صرف.

الطريق ٣ — non-blocking + إشعار الجاهزية من النواة (الحلّ)

ماذا لو قلتَ للنواة: "هذه ألفُ fd. نوّمني، وأيقظني فقط حين يصير أيٌّ منها جاهزاً، وقل لي أيّها"؟ هذا بالضبط ما تفعله select/poll، وبكفاءةٍ عالية epoll (لينكس) وkqueue (BSD/ماك):

c
int epfd = epoll_create1(0);
// سجّل كل الـ fds التي تهمّك...
while (1) {
    int n = epoll_wait(epfd, events, MAX, -1);   // ← ينام هنا، صفر CPU، حتى جاهزية
    for (int i = 0; i < n; i++) {
        handle(events[i].data.fd);                // عالِج فقط ما جهُز فعلاً
    }
}

هذا الهيكل — حلقةٌ واحدةٌ تنام على epoll_wait، تستيقظ على الأحداث الجاهزة، تنادي لكلٍّ معالِجَه، ثم تعود تنام — له اسمٌ في تصميم الأنظمة: نمط المُفاعِل (reactor pattern)، أو حلقة الأحداث (event loop). خيطٌ واحد، لا حجب، لا busy poll، يخدم عشرات الآلاف لأن الانتظار "مجّانيٌّ" (نومٌ في النواة)، والعمل الوحيد هو معالجة ما جهُز فعلاً.

فلماذا JavaScript بالذات لبست هذا النمط؟

هنا الجمال: JS وُلدت أصلاً على هذا الشكل. في المتصفّح خيطُ واجهةٍ واحد، وكلُّ شيءٍ حدثٌ ذو callback: "حين يُنقَر هذا الزرّ، نفّذ هذه الدالة". لا خيوط، لا read() حاجب — حلقةُ أحداثٍ تنادي callbacks. حين أراد Ryan Dahl خادماً يحلّ C10K بأناقة، وجد لغةً شكلُها هو شكلُ المُفاعِل سلفاً: خيطٌ واحد، دوالٌّ كقيمٍ (الإغلاق من الإقليم ١!)، وثقافةُ callbacks. ركّب محرّك V8 (الذي ينفّذ JS) فوق مكتبة libuv (التي تجرّد epoll/kqueue/IOCP عبر الأنظمة)، فولدت Node.

كيف: تشريح آلة Node

القطعة الواحدة، والحلقة

في أي لحظة، خيطٌ واحدٌ ينفّذ JS — لديه call stack واحد، تماماً كـ C: تُنادى دالةٌ فتُكدَّس، تعود فتُنزَع. القاعدة الحديدية: ما دامت دالةٌ على الـ stack، لا شيءَ آخرَ يعمل — لا callback، لا طلب، لا شيء. الحلقة معطّلة حتى يفرغ الـ stack.

حين تنادي عمليةَ I/O غير متزامنة (اقرأ ملفاً، استعلم قاعدة بيانات، انتظر شبكة)، لا تحجب. بدلاً منها:

1. Node يسلّم العملية لـ libuv (التي تسجّل الـ fd في epoll، أو ترميها لمجمّع خيوط — انظر أدناه).
2. تسجّل callback (إغلاق! يحمل سياقه) ليُنادى عند الاكتمال.
3. الدالة الحالية تكمل وتعود فوراً، يفرغ الـ stack، وتتحرّر الحلقة لخدمة غيرها.
4. لاحقاً، حين تخبر النواةُ libuv أن العملية جهُزت، تضع الحلقةُ الـ callback في طابور لتنفّذه حين يفرغ الـ stack.

طابوران: المهامّ الكبرى والمهامّ الدقيقة (macro/microtasks)

ليس طابوراً واحداً، بل تراتبيّةٌ تحدّد ترتيب تنفيذ ما أُجِّل:

• Macrotask queue (طابور المهامّ): setTimeout، أحداث I/O، إلخ. الحلقة تأخذ واحدةً في كل دورة.
• Microtask queue (طابور المهامّ الدقيقة): callbacks الـ Promise (.then/await). يُفرَّغ بالكامل بعد كل مهمّةٍ كبرى وقبل الكبرى التالية — أولويةٌ أعلى.

القاعدة التنفيذية: نفّذ الكود المتزامن حتى يفرغ الـ stack → فرّغ كل الـ microtasks → خذ macrotask واحدة → فرّغ كل الـ microtasks ثانيةً → وهكذا. هذا يفسّر اللغز الكلاسيكيّ:

js
console.log("1");
setTimeout(() => console.log("2"), 0);          // macrotask
Promise.resolve().then(() => console.log("3")); // microtask
console.log("4");
// الترتيب: 1 ، 4 ، 3 ، 2
// المتزامن أولاً (1،4)، ثم تُفرَّغ microtasks (3)، ثم macrotask (2) — رغم أن مهلتها صفر!

setTimeout(fn, 0) لا يعني "نفّذ الآن"، بل "ضعه في طابور المهامّ الكبرى لأقرب دورة" — وكلُّ الـ microtasks تسبقه. هذه ليست تفاهة: ترتيبُ آثارٍ خفيٍّ كهذا مصدرُ أخطاءٍ حقيقيةٍ ستلتقيها.

حلُّ لغز await: ينتظر دون أن يحجب

الآن نحسم تناقض الإقليم ١. await somePromise:

1. يعلّق الدالة الـ async عند هذا السطر، ويحفظ "بقيّتها" (ما بعد await) كأنها callback (إغلاقٌ يلتقط كل متغيّراتها المحلية).
2. يعيد التحكّم فوراً للحلقة — يفرغ الـ stack، فتخدم الحلقةُ طلباتٍ أخرى.
3. حين يُحَلّ الـ Promise، تُجدوَل "البقيّة" في طابور microtasks، فتُستأنف الدالة من حيث تعلّقت.

إذن "الانتظار" هنا = تنازلٌ للحلقة + استئنافٌ لاحقٌ عبر callback، لا حجزُ الخيط. لهذا يخدم خادمٌ بخيطٍ واحدٍ آلافَ الطلبات المتزامنة التي كلٌّ منها "ينتظر" قاعدةَ البيانات: بينما ينتظر طلبٌ استعلامَه، الخيطُ يخدم العشرات غيره. await سكّرٌ نحويٌّ جميلٌ فوق "سجّل callback وتنازل" — يجعل الكود يُقرأ متسلسلاً وهو يُنفَّذ مُشذَّراً. هذه عبقرية النموذج.

الشرخ الخطير: العمل المحسوب يجمّد الجميع

ما دام خيطٌ واحدٌ ينفّذ JS، فإن أي عملٍ متزامنٍ طويل (حلقةُ حسابٍ ثقيلة، تجزئةٌ متزامنة، معالجةُ ملفٍّ ضخمٍ في الذاكرة) يحتكر الـ stack ويجمّد الحلقة كلّها — كل العملاء يتسمّرون حتى ينتهي. هذا أخطر فخٍّ في Node:

js
// كارثة: يجمّد كل الطلبات لثوانٍ
app.get("/bad", (req, res) => {
  let s = 0;
  for (let i = 0; i < 5e9; i++) s += i;   // عملٌ محسوبٌ متزامن طويل
  res.json({ s });
});

علاجٌ ثلاثيّ، كلّه "أخرِج العمل الثقيل من خيط الحلقة":

• مجمّع خيوط libuv (thread pool): بعضُ عملياتِ المكتبة القياسية ثقيلةٌ بطبعها (نظام الملفّات، DNS، التعمية/التجزئة). libuv يشغّلها على مجمّع خيوطٍ صغير (٤ افتراضياً) بعيداً عن خيط الحلقة، فلا تحجبه. لهذا bcrypt غير متزامن (الإقليم ٧): تجزئةُ كلمة المرور حسابٌ ثقيلٌ عمداً؛ لو جرت متزامنةً على خيط الحلقة لجمّدت الخادم عند كل تسجيل. تجري على المجمّع، فتُنتظَر بـ await بلا حجب.
• عمليّاتٌ منفصلة (child_process): للعمل الأثقل أو الخارجيّ، فرّع عمليةً مستقلّةً لها خيطها ونواتها. هذا بالضبط ما يفعله نظام التصحيح في الإقليم ١٠: لا يصرّف ويشغّل كودَ C على خيط الحلقة — يفرّع docker/gcc كعمليّاتٍ خارجية ويتواصل معها لا-حاجباً. (تذكّر: خيطُ الحلقة مقدّسٌ، لا تحجبه أبداً.)
• Worker threads: خيوطُ JS حقيقيةٌ منفصلةٌ للحساب الثقيل الخالص (نادرٌ في خادمٍ نمطيّ؛ بذرة).

كيف: من أين تأتي express؟ (الوحدات و npm)

في الإقليم ١ سألت: import express from "express" بلا ./ — من أين؟ الجواب نظامُ حزم Node:

• node_modules/: مجلّدٌ تُنزَّل فيه التبعيّات. حين تستورد اسماً بلا مسار (express)، يبحث Node صعوداً في node_modules حتى يجده. باسمٍ بمسار (./x)، يأخذه نسبةً لملفّك (وحدةٌ من تأليفك). فرقٌ بسيطٌ يفسّر كل استيراداتك.
• package.json: بطاقةُ المشروع — اسمه، scripts (dev/build/start في مشروعك)، وdependencies (يلزم وقت التشغيل: express, prisma, bcrypt, zod...) مقابل devDependencies (يلزم وقت التطوير فقط: typescript, tsx, nodemon, @types/*).
• package-lock.json: تثبيتٌ دقيقٌ للنسخ المتعدّية (transitive) كي يحصل كلُّ من يبني المشروع على نفس الشجرة بالضبط. هذا ما يقرؤه npm ci في Dockerfile مشروعك (npm ci = تثبيتٌ نظيفٌ مطابقٌ للقفل، أسرع وأحسم من npm install للـ CI والصور).
• semver (^6.19.3): قواعدُ ترقيةٍ متوافقة. ^ يسمح بالترقيعات والميزات المتوافقة، لا الكاسرة. (يربط بانضباط النسخ الذي تعرفه.)

@types/express في devDependencies مشروعك يستحقّ وقفة: حزمةٌ تحوي تعليقات TypeScript فقط لمكتبةٍ كُتبت بـ JS. لأن الأنواع تُمحى (الإقليم ١)، تُوزَّع منفصلةً كي يحرسك المترجمُ وقتَ الكتابة دون أن تُثقِل وقت التشغيل. تطبيقٌ مباشرٌ للـ erasure.

كيف: process، البيئة، والـ globals

Node ليس متصفّحاً: لا window ولا document ولا DOM. بدلاً منها process (العمليّة نفسها) وعالمُ خادم:

• process.env: متغيّرات البيئة — وعاءُ الإعدادات والأسرار. مشروعك يقرأ منها process.env.PORT، DATABASE_URL، JWT_SECRET (تذكّر .env.example). لماذا البيئة لا ملفُّ ثوابت؟ كي يختلف الإعداد بين تطويرٍ وإنتاجٍ دون تغيير الكود، وكي لا تُلتزَم الأسرار في git (تذكّر Fix: Restored .env.example after security breach في تاريخ مشروعك — درسٌ حيّ). dotenv يحمّل .env إلى process.env للتطوير.
• process.argv: وسائط سطر الأوامر (كـ argv في C تماماً).
• process.on("SIGTERM", ...): التقاطُ الإشارات (تعرفها من C) لإغلاقٍ نظيف.
• الـ globals المفيدة: console، Buffer (بايتاتٌ خام — أقربُ ما في JS لمصفوفة unsigned char في C؛ به تتعامل مع الجسم الثنائيّ للطلب)، setTimeout.

Streams: الجسم يصل قطعاً (يربط تأطير الإقليم ٠)

req وres في Node ليسا قيمتين جاهزتين — هما streams: الجسم لا يصل دفعةً، بل قطعاً (chunks) عبر أحداث data، حتى حدثِ end. تذكّر تأطير الإقليم ٠: لا حدودَ للرسائل في TCP، فتقرأ حتى تستوفي Content-Length. هكذا تقرأ الجسمَ الخام في Node:

js
let body = "";
req.on("data", (chunk) => { body += chunk; });   // قطعةٌ قطعة
req.on("end", () => { const data = JSON.parse(body); /* ... */ });

هذا مملٌّ ومتكرّرٌ لكل طلب — وهنا يولد العجز الذي يسدّه Express (الإقليم ٣): express.json() يفعل هذا التجميع والتحويل عنك. لكنك سترى الآلية الخام أولاً كي لا يكون الإطار سحراً.

اللغز / البناء من الصفر

js
console.log("A");
setTimeout(() => console.log("B"), 0);
Promise.resolve().then(() => console.log("C")).then(() => console.log("D"));
(async () => { console.log("E"); await null; console.log("F"); })();
console.log("G");

الخلاصة — أين تتّصل هذه العقدة بالشجرة

الوصلة للواقع (نمط SelfLab)

ارجع إلى backend/src/server.ts:

ts
const PORT = process.env.PORT || 3000;       // البيئة، لا ثابت
app.listen(PORT, () => { console.log(...) }); // يسجّل الخادم في الحلقة ويبقيها حيّة

app.listen يفتح socket استماعٍ ويسجّله في حلقة libuv، فلا "ينتهي" البرنامج — الحلقة حيّةٌ تنتظر اتصالات (نومٌ على epoll_wait، صفر CPU بين الطلبات). والمعالِج في user.controller.ts:

ts
export async function createUser(req: Request, res: Response) {
  // ...
  password: await bcrypt.hash(password, 10),   // ينتظر مجمّعَ الخيوط بلا حجب الحلقة
  const newUser = await prisma.user.create(...) // ينتظر قاعدةَ البيانات بلا حجب
}

async لأن فيه await؛ وكلُّ await هنا تنازلٌ للحلقة كي تخدم طلباتٍ أخرى أثناء انتظار التجزئة وقاعدة البيانات. بينما يُجزّئ هذا الطلبُ كلمةَ مرورٍ على المجمّع، يخدم خيطُ الحلقة عشراتٍ غيره. هذا هو "كيف لا ينام خيطٌ واحد" في كود مشروعك حرفياً.