Real-time capstone 1: chat arxitekturasi va xabarlar — SSE, takror himoyasi, tarix va o'qildi belgisi
Qisqacha:
jamoachati ikki yo'ldan iborat. Mijoz serverga oddiyPOSTbilan yozadi, server mijozga SSE oqimi orqali yuboradi. Xabar avval Postgres'ga yoziladi, keyin Redis kanaliga e'lon qilinadi. Takror yuborishmijozIdbilan ushlanadi, uzilib qayta ulanish esaLast-Event-IDbilan tiklanadi. Kanon testlari yashil. Lekin lokal production'da biz o'lchaganda tarix "eng eski 200 ta" ekani chiqdi: 201-xabardan boshlab yangi ulanish ularni ko'rmaydi.
Bu darsda
- Chat uchun transport tanlaysiz: WebSocket, SSE yoki polling — o'lchov va kod hajmi bilan.
- Xabar yo'lini qurasiz:
POST→ tranzaksiya → Redis → hamma nusxadagi SSE ulanishlar. - Takror xabarni
mijozIdvaUNIQUEbilan, o'tkazib yuborilganlarniLast-Event-IDbilan hal qilasiz. - O'qildi belgisi va o'qilmaganlar sonini yozasiz.
- Kanon kodidagi tarix chegarasi va "teshik"ni topib, tuzatish rejasini yozasiz.
Oldin bilishingiz kerak: SaaS capstone 4, Server-Sent Events, WebSocket protokoli, Realtime'ni masshtablash, Dizayn: chat, Pub/Sub va Redis Streams.
1. Nega bu kerak?
jamoa da vazifalar bor, lekin jamoa a'zolari ular haqida qayerda gaplashadi? Hozircha — boshqa ilovada. Har bir "bu vazifa bo'yicha savol" Telegram'ga ketadi va kontekst yo'qoladi. Chat mahsulot ichida qolsa, vazifa va muhokama yonma-yon turadi.
Texnik jihatdan chat — capstone'ning eng qiziq qismi. U oldingi darslarda qurilgan hamma narsani sinaydi: ikki api nusxasi (stateless bo'lishi kerak), RLS (begona jamoa xabarini ko'rmaslik), idempotentlik (tarmoq uzilganda takror), nginx sozlamasi (bufersiz oqim). Bir joyda xato bo'lsa, foydalanuvchi buni darhol sezadi: xabar kelmaydi yoki ikki marta keladi.
Hayotiy o'xshatish: maktabdagi e'lonlar taxtasi va radiouzel. O'quvchi e'lon yozmoqchi bo'lsa, uni direktor xonasiga olib boradi (POST). Direktor uni jurnalga yozadi (baza), keyin radiouzel orqali hamma sinflarga o'qiydi (SSE). Kimdir tanaffusda bo'lsa, qaytib kelganda jurnaldan "men yo'qligimda nima e'lon qilindi?" deb so'raydi (Last-Event-ID). Bitta e'lonni ikki marta olib kelsa, direktor jurnalda bor ekanini ko'radi va qayta o'qimaydi (mijozId).
Transportlarning nazariyasi WebSocket va Server-Sent Events, Server-Sent Events va Socket.IO darslarida bor. Bu darsda qaror va uning narxi.
2. Talab
| Hikoya | Asosiy mezon | Natija |
|---|---|---|
| Xabar yozaman | jamoa a'zosi, Origin to'g'ri | 201, xabar |
| Jamoadoshim ko'radi | u boshqa api nusxasiga ulangan | SSE'da event: xabar |
| Tarmoq uzildi, qayta yubordim | o'sha mijozId |
200, o'sha xabar, bazada bitta |
| Uzilib, qayta ulandim | Last-Event-ID |
faqat o'tkazib yuborilganlar |
| O'qidim | PUT /oqildi |
o'qilmaganlar 1 → 0, boshqalarga event: oqildi |
| Begona jamoa chati | a'zo emas | 404 |
Maqsad emas (MVP): jamoa ichida bir nechta xona, "yozmoqda…" holati, fayl biriktirish, xabarni tahrirlash va o'chirish. Kanon jadvalining izohi aniq: "MVP — bitta umumiy kanal". Xonalar va "yozmoqda" — «O'zingiz qiling» bo'limida.
3. Qarorlar
3.1 Transport: WebSocket, SSE yoki polling
ADR-0008 uchta variantni solishtirdi:
| Variant | Afzallik | Kamchilik (jamoa uchun) |
|---|---|---|
| WebSocket (ws, Socket.IO) | ikki tomonlama, kam qo'shimcha bayt | nginx'da Upgrade sozlamasi, alohida auth va CSRF yo'li, qayta ulanish va "o'tkazib yuborilganlar" — o'zimiz yozardik |
| SSE + POST (kanon) | oddiy HTTP; cookie, CSRF, rol tekshiruvi REST bilan bir xil; brauzer qayta ulanishni o'zi qiladi | faqat server → mijoz; HTTP/1.1 da bir domenga 6 ulanish chegarasi |
| Polling (har 2 s) | eng oddiy | 400 a'zo × har 2 s = 200 so'rov/s bo'sh |
Polling raqamini o'zingiz hisoblang: 400 ta ochiq oyna, har biri 2 soniyada bir so'raydi — 400 / 2 = 200 so'rov/s. jamoa ning kutilgan cho'qqi yuki esa taxminan 3 so'rov/s (ADR-0001). Ya'ni polling yukni 60 barobardan ko'p oshiradi va bu so'rovlarning deyarli hammasi bo'sh javob oladi (Taxminiy hisob-kitob).
Hal qiluvchi dalil — chat'da mijoz kam yozadi, ko'p o'qiydi. Yozish — kamdan-kam POST, uni REST'dagi hamma himoya (Origin, rol, Zod) bilan qayta ishlatamiz. O'qish — bitta uzoq javob. WebSocket bu yerda ortiqcha kuch: ikki tomonlama kanal kerak bo'ladigan o'yin, hamkorlikda tahrirlash yoki ovozli qo'ng'iroq uchun.
Narxi ham yozilgan. HTTP/1.1 da brauzer bitta domenga 6 tadan ortiq ulanish ochmaydi — bu chegara hamma tablar uchun umumiy. Foydalanuvchi jamoa ni 7 ta tabda ochsa, yettinchisi osilib qoladi. HTTP/2 da bitta ulanish ichida ko'p oqim bo'ladi (sukut bo'yicha odatda 100 ta) — xost nginx'ida http2 yoqilsa, muammo amalda yo'qoladi (HTTP versiyalari va real-time aloqa).
3.2 Avval baza, keyin e'lon
Xabar ikki joyga ketadi: Postgres (tarix) va Redis (jonli tarqatish). Tartib muhim.
| Tartib | Nima bo'ladi, agar orasida yiqilsa |
|---|---|
| avval Redis, keyin baza | mijozlar xabarni ko'rdi, lekin u bazada yo'q — sahifa yangilanganda yo'qoladi |
| avval baza (COMMIT), keyin Redis (kanon) | xabar bazada, jonli kelmadi — qayta ulanishda tarixdan keladi |
Kanon ikkinchisini tanladi. Yo'qotish ehtimoli bor joy — faqat "jonli ko'rsatish", ma'lumotning o'zi emas. Bu Transactional outbox naqshi ning soddalashgan ko'rinishi: kafolatli yetkazish emas, kafolatli saqlash.
3.3 Takror: mijozId yoki Idempotency-Key
vazifalar-api 4.5.0 da Idempotency-Key sarlavhasi va Postgres ombori bor (Capstone metodologiyasi). Chat'da kanon boshqa yo'l tanladi: xabarning o'zida mijoz_id maydoni va UNIQUE (jamoa_id, muallif_id, mijoz_id).
| Variant | Afzallik | Kamchilik |
|---|---|---|
Idempotency-Key ombori |
umumiy mexanizm, istalgan endpoint uchun | alohida jadval, muddat, javob nusxasi |
mijoz_id + UNIQUE (kanon) |
bitta jadval, abadiy, sodda | faqat shu jadval uchun |
Chat xabari uchun ikkinchisi tabiiy: xabar o'zi "bir marta yaratiladigan narsa", uning mijoz tomonidagi identifikatori esa optimistik ko'rsatish uchun baribir kerak — xabar serverga yetmasdan ekranda paydo bo'ladi.
3.4 Kanal: Redis pub/sub yoki Redis Streams
Ikki api nusxasi bir-biriga xabar uzatishi uchun umumiy kanal kerak. Redis'da ikki tayyor vosita bor (Pub/Sub va Redis Streams):
| Variant | Afzallik | Kamchilik |
|---|---|---|
| pub/sub (kanon) | eng oddiy; xabar faqat hozir obuna bo'lganlarga | obunachi yo'q paytdagi e'lon yo'qoladi |
| Streams | e'lonlar saqlanadi, o'qish joyi (offset) bilan | tozalash, guruhlar va tasdiqlash — qo'shimcha kod |
Kanon pub/sub'ni tanladi, chunki "saqlash" vazifasini Postgres allaqachon bajaryapti. Redis'dagi e'lon — faqat "hozir ulangan mijozlarga tezroq yetkazish" uchun signal. U yo'qolsa, xabar baribir bazada va mijoz uni qayta ulanishda Last-Event-ID orqali oladi. Ikkita saqlash joyi (Postgres va Streams) bo'lsa, ular qaysi biri haqiqat ekani haqida bahslasha boshlaydi.
Bu qarorning narxi bitta: e'lon yo'qolsa, mijoz xabarni darhol ko'rmaydi. Agar undan keyin boshqa xabar jonli kelib ulgursa, Last-Event-ID yo'qolgan xabardan oshib ketadi — u holda faqat sahifani yangilash yordam beradi. Quyida ko'rasiz, kanonda aynan shunday holat bor — Redis'ning o'zi emas, kod tartibi tufayli.
Tekshirib ko'ring: Nega
UNIQUEkalitgamuallif_idham kiritilgan? Faqat(jamoa_id, mijoz_id)bo'lsa nima bo'lardi?
Javob
mijoz_id ni mijoz o'zi yaratadi, ya'ni uni nazorat qilmaymiz. Agar kalit faqat (jamoa_id, mijoz_id) bo'lsa, bitta a'zo boshqa a'zoning mijoz_id sini (masalan, SSE'dan ko'rib) qayta yuborib, uning yangi xabarlarini "takror" deb bloklashi mumkin edi. Javobda esa begona xabar qaytardi. muallif_id bilan har foydalanuvchining identifikatorlari o'z maydonida — boshqa birovniki bilan to'qnashmaydi.
4. Qurish
sequenceDiagram
participant M as Muallif
participant A as api nusxa A
participant P as Postgres
participant R as Redis
participant B as api nusxa B
participant O as O'quvchi (SSE)
O->>B: GET /chat/oqim (cookie)
B->>R: SUBSCRIBE jamoa:chat:7
M->>A: POST /chat/xabarlar {matn, mijozId}
A->>P: INSERT … ON CONFLICT DO NOTHING, COMMIT
A-->>M: 201
A->>R: PUBLISH jamoa:chat:7
R-->>B: xabar
B-->>O: id: 41, event: xabarMuallif va o'quvchi turli nusxalarda. Ular orasidagi yagona umumiy narsa — Postgres va Redis. Shuning uchun api nusxalari stateless qoladi: ulanishlar ro'yxati har nusxaning xotirasida, lekin xabarning o'zi hech qachon faqat xotirada emas.
4.1 Sxema
Jadval va RLS siyosati (sql/001-jamoa.sql, qatorga bo'lindi, ENABLE ROW LEVEL SECURITY qatorlari qisqartirildi):
CREATE TABLE xabarlar (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
jamoa_id bigint NOT NULL REFERENCES jamoalar (id)
ON DELETE CASCADE,
muallif_id bigint NOT NULL REFERENCES foydalanuvchilar (id),
matn text NOT NULL
CHECK (length(matn) BETWEEN 1 AND 2000),
mijoz_id text NOT NULL,
yaratilgan_vaqt timestamptz NOT NULL DEFAULT now(),
UNIQUE (jamoa_id, muallif_id, mijoz_id)
);
CREATE INDEX xabarlar_jamoa_idx ON xabarlar (jamoa_id, id);
CREATE POLICY xabarlar_jamoa ON xabarlar
USING (jamoa_id = joriy_jamoa() AND azomi(jamoa_id))
WITH CHECK (jamoa_id = joriy_jamoa() AND azomi(jamoa_id)
AND muallif_id = joriy_foydalanuvchi());WITH CHECK ning oxirgi sharti — muallif_id = joriy_foydalanuvchi(). Kod xato bilan boshqa muallif_id yuborsa ham, baza uni rad etadi. Bu SaaS capstone 1 dagi ikki qatlamli RLS: kontekst (joriy_jamoa()) va bazadagi a'zolik (azomi()).
oqildi jadvali — har a'zo uchun bitta qator: oxirgi o'qilgan xabar id'si. Birlamchi kalit (jamoa_id, foydalanuvchi_id), tashqi kalit esa azoliklar ga — a'zo jamoadan chiqarilsa, uning belgisi ham o'chadi.
4.2 Yozish: bitta so'rovda "yangi yoki o'sha"
yoz() metodi (qatorga bo'lindi, kanon bilan aynan; SQL shablon satri … bilan qisqartirildi va pastda alohida):
async yoz(jamoa: number, f: Foydalanuvchi, xom: unknown)
: Promise<{ xabar: Xabar; yangi: boolean }> {
const b = tekshir(XabarSxemasi, xom, "body");
const n = await tx(this.pool, async (c) => {
const { rows: [q] } = await c.query<
{ id: string; yaratilgan_vaqt: Date; yangi: boolean }>(
`WITH y AS (…) …`,
[jamoa, f.id, b.matn, b.mijozId]);
if (q === undefined) throw new Error("xabar yozilmadi");
return { xabar: { id: Number(q.id), muallifId: f.id, matn: b.matn,
vaqt: q.yaratilgan_vaqt.toISOString() }, yangi: q.yangi };
}, { foydalanuvchi: f.id, jamoa });
// COMMIT'dan keyin tarqatish
if (n.yangi) await this.pub.publish(this.#kanal(jamoa),
JSON.stringify({ tur: "xabar",
x: { ...n.xabar, t: Date.now() } }));
return n;
}Shablon satridagi SQL (qatorga bo'lindi):
WITH y AS (
INSERT INTO xabarlar (jamoa_id, muallif_id, matn, mijoz_id)
VALUES ($1, $2, $3, $4)
ON CONFLICT (jamoa_id, muallif_id, mijoz_id) DO NOTHING
RETURNING id, yaratilgan_vaqt)
SELECT id, yaratilgan_vaqt, true AS yangi FROM y
UNION ALL
SELECT id, yaratilgan_vaqt, false FROM xabarlar
WHERE jamoa_id = $1 AND muallif_id = $2 AND mijoz_id = $4
AND NOT EXISTS (SELECT 1 FROM y);Bitta so'rov ikki holatni qamraydi. Yangi xabar bo'lsa, INSERT qator qaytaradi va birinchi SELECT uni yangi = true bilan beradi. Takror bo'lsa, ON CONFLICT DO NOTHING hech narsa qaytarmaydi, ikkinchi SELECT esa mavjud qatorni yangi = false bilan topadi. Controller shunga qarab 201 yoki 200 qaytaradi.
Nega ikki alohida so'rov ("bormi? yo'q bo'lsa yoz") emas? Chunki ular orasida boshqa nusxadan xuddi shu takror kelishi mumkin — klassik poyga. ON CONFLICT uni baza darajasida, qulfsiz hal qiladi.
if (n.yangi) — takror xabar qayta e'lon qilinmaydi. Aks holda SSE'dagi hamma mijoz uni ikki marta oladi.
Mana shu mantiqning brauzerdagi kichik modeli:
// server modeli: xabarlar va UNIQUE (jamoa, muallif, mijozId)
const xabarlar = [];
const noyob = new Map();
function yoz(jamoa, muallif, matn, mijozId) {
const kalit = `${jamoa}:${muallif}:${mijozId}`;
const bor = noyob.get(kalit);
if (bor) return { holat: 200, xabar: bor }; // takror — o'sha
const xabar = { id: xabarlar.length + 1, matn };
xabarlar.push(xabar);
noyob.set(kalit, xabar);
return { holat: 201, xabar };
}
// SSE ulanish: Last-Event-ID dan keyingilari (kanondagidek LIMIT 200)
const tarix = (oxirgi) =>
xabarlar.filter((x) => x.id > oxirgi).slice(0, 200);
const birinchi = yoz(1, 7, "Salom, jamoa!", "mijoz-0001");
const takror = yoz(1, 7, "Salom, jamoa!", "mijoz-0001"); // javob yo'q
console.log(birinchi.holat, takror.holat, "id:", takror.xabar.id);
yoz(1, 7, "xabar 2", "mijoz-0002"); // mijoz shu paytda oflayn
yoz(1, 7, "xabar 3", "mijoz-0003");
const otkazilgan = tarix(1).map((x) => x.matn).join(", ");
console.log("Last-Event-ID: 1 →", otkazilgan);
console.log("bazada:", xabarlar.length, "ta xabar");Konsolda:
201 200 id: 1
Last-Event-ID: 1 → xabar 2, xabar 3
bazada: 3 ta xabarNatija kanon testi bilan bir xil: birinchi POST — 201, takror — 200 va o'sha id, Last-Event-ID bilan qayta ulanish — faqat ["xabar 2", "xabar 3"].
4.3 O'qish: SSE oqimi
oqim() metodi (qatorga bo'lindi, kanon bilan aynan):
async oqim(req: Request, res: Response, jamoa: number,
f: Foydalanuvchi): Promise<void> {
res.writeHead(200, {
"Content-Type": "text/event-stream; charset=utf-8",
"Cache-Control": "no-store",
"X-Accel-Buffering": "no",
Connection: "keep-alive" });
res.write("retry: 3000\n\n"); // sarlavhalar darhol ketsin
const oxirgi = Number(req.get("last-event-id") ?? 0) || 0;
for (const x of await this.tarix(jamoa, f, oxirgi))
res.write(`id: ${String(x.id)}\nevent: xabar\ndata: ${
JSON.stringify(x)}\n\n`);
const u: Ulanish = { res, f: f.id, jamoa };
this.#ulanishlar.add(u);
await this.#obuna(jamoa);
await this.#korindi(jamoa, f.id);
this.#yurak ??= setInterval(() => {
void this.#yurakUrishi(); }, 15_000);
req.on("close", () => {
this.#ulanishlar.delete(u);
void this.#obunaBekor(jamoa);
});
}Qatorma-qator asosiy qarorlar:
- Sarlavhalar.
X-Accel-Buffering: no— nginx'ga "bu javobni buferlama" degan signal (ichki nginx'daproxy_buffering offham bor, SaaS capstone 4).Cache-Control: no-store— oraliq proksi oqimni keshlamasin. retry: 3000— brauzer uzilganda 3 soniyadan keyin qayta ulanadi. Bu qatorning ikkinchi, muhimroq vazifasi bor — pastdagi «Biz shunday xato qildik».Last-Event-ID— brauzer qayta ulanganda oxirgi olganid:ni shu sarlavhada o'zi yuboradi. Server tarixdan undan keyingilarini beradi. Mijoz kodida hech narsa yozish shart emas.- Auth. SSE — oddiy
GET. Cookie o'zi boradi, controller esa oqimni ochishdan oldinjamoalar.rol()bilan a'zolikni tekshiradi. A'zo bo'lmasa — 404, oqim umuman ochilmaydi. WebSocket'dagi "handshake paytidagi auth" muammosi bu yerda yo'q. req.on("close")— ulanish uzilganda ro'yxatdan o'chirish va Redis obunasini kamaytirish. Bu qator bo'lmasa, yopilgan ulanishlarga yozish urinishlari va xotira oqishi boshlanadi.
Brauzer tomoni (web/src/main.tsx) — atigi bir necha qator: new EventSource(url), addEventListener("xabar", …). Kelgan xabar id bo'yicha tekshiriladi: ro'yxatda bor bo'lsa, qo'shilmaydi. Bu mijoz tomonidagi takror himoyasi — qayta ulanishda server bir xabarni ikki marta yuborsa ham, ekranda bitta.
4.4 Biz shunday xato qildik: 15 soniyalik jimlik
jamoa chatining birinchi variantida res.write("retry: 3000\n\n") qatori yo'q edi. Test yangi jamoada SSE ulanish ochdi va birinchi hodisani kutdi. Mijoz 15 soniyadan ko'proq kutdi.
Sabab Node'ning HTTP xulqida. res.writeHead() sarlavhalarni darhol yubormaydi — ular birinchi write() gacha yig'ilib turadi. Tarix bo'sh bo'lsa, hech narsa yozilmaydi. Birinchi yozuv esa 15 soniyadan keyingi yurak urishi (: yurak). Shu vaqtgacha mijoz hatto javob sarlavhalarini ham olmaydi: brauzerdagi EventSource open hodisasini bermaydi, fetch esa await da osilib turadi.
Tuzatish — sarlavhalardan keyin darhol bitta foydali qator yozish. retry: buning uchun ideal: u hodisa emas (mijoz ilovasiga hech narsa kelmaydi), lekin brauzer uchun ma'noli. Natija (ADR-0008 dagi o'lchov): 15.6 s → 0.57 s. Xom log saqlanmagan, raqamlar kanon ADR'idan.
Node hujjati bu xulqni ochiq yozadi: samaradorlik uchun Node sarlavhalarni birinchi ma'lumot bo'lagi bilan bitta TCP paketga qo'shib yuborishga harakat qiladi. Shu maqsadda res.flushHeaders() metodi ham bor — u sarlavhalarni darhol jo'natadi. Kanon retry: ni tanladi, chunki u bitta qatorda ikki ish qiladi. flushHeaders() varianti kanonda sinalmagan.
Saboq: oqimli javobning birinchi baytini darhol yuboring. Bu SSE, uzun so'rov (long polling) va fayl yuklab berishning hammasiga tegishli. "Hozircha aytadigan gapim yo'q" degan server mijoz uchun "server javob bermayapti" bilan bir xil.
4.5 O'qildi belgisi
PUT /chat/oqildi — { xabarId }. Bazada (shablon satridagi SQL, qatorga bo'lindi):
INSERT INTO oqildi (jamoa_id, foydalanuvchi_id, xabar_id)
SELECT $1, $2, $3 WHERE EXISTS (SELECT 1 FROM xabarlar WHERE id = $3)
ON CONFLICT (jamoa_id, foydalanuvchi_id)
DO UPDATE SET xabar_id = greatest(oqildi.xabar_id, EXCLUDED.xabar_id);Ikki himoya. greatest() — belgi faqat oldinga siljiydi. Ikkita tab parallel ravishda "41 o'qildi" va "39 o'qildi" yuborsa, natija 41 qoladi, tartibga bog'liq emas. WHERE EXISTS — mavjud bo'lmagan xabar id'si yozilmaydi. RLS tufayli xabarlar da faqat joriy jamoa xabarlari ko'rinadi, demak boshqa jamoaning xabar id'si bilan ham belgi qo'yib bo'lmaydi.
Keyin oqildi hodisasi Redis orqali hammaga ketadi. Boshqa a'zolar "ko'rildi" belgisini ko'rsata oladi.
O'qilmaganlar soni — bitta so'rov: oxirgi o'qilgan id'dan katta va o'zim yozmagan xabarlar soni.
5. Tekshirish
5.1 Kanon testi: ikki nusxa, bitta Redis
test/chat.test.ts ikkita api nusxasini (A va B) bitta baza va bitta Redis bilan ko'taradi:
| Qadam | Natija |
|---|---|
a'zo B dagi SSE'ga ulanadi; egasi A ga POST |
201 |
xuddi shu mijozId bilan B ga POST |
200, o'sha id |
| B dagi SSE | event: xabar, matn Salom, jamoa! |
| tarix | 1 xabar, o'qilmagan 1, onlayn 1 |
PUT /oqildi |
204; o'qilmagan 0; SSE'da event: oqildi |
uzilgan paytda 2 xabar; Last-Event-ID bilan qayta ulanish |
faqat ["xabar 2", "xabar 3"] |
| begona foydalanuvchi | 404 |
To'liq to'plam: npm run check — 11/11, shu jumladan lokal act da. Yuk o'lchovi (100 va 400 ulanish) — keyingi darsda.
5.2 Natijani halol o'qish: tarix — "eng eski 200 ta"
tarix() ning SQL'i:
SELECT id, muallif_id, matn, yaratilgan_vaqt FROM xabarlar
WHERE id > $1 ORDER BY id LIMIT 200Last-Event-ID bilan qayta ulanishda bu to'g'ri: "shu id'dan keyingi 200 ta". Lekin birinchi ulanishda $1 = 0. Natija — jamoa tarixidagi eng eski 200 ta xabar. GET /chat/xabarlar ham shu funksiyani chaqiradi.
Buni kanon image'lari bilan lokal production stack'ida (nginx + 2 nusxa) o'lchadik. Skript 205 ta xabar yozadi, keyin yangi foydalanuvchi kabi ulanadi (skript va natija mashq papkasidagi olchov/ da):
yozildi: 205; GET /chat/xabarlar: 200 ta, birinchisi "xabar 1", oxirgisi "xabar 200"
yangi SSE ulanish (Last-Event-ID yo'q): 200 ta, birinchisi "xabar 1", oxirgisi "xabar 200"
ekranga chiqmaganlar: 5 ta (xabar 201 … xabar 205)
jonli: "xabar 206" keldi; jami 201 taYa'ni jamoa 200 ta xabardan o'tgach, sahifani yangi ochgan har kim eng eski xabarlarni ko'radi va oxirgi muhokamani ko'rmaydi. Faqat ulanib turgan paytda kelgan yangi xabarlar paydo bo'ladi. Xato xabari ham, "yana yuklash" tugmasi ham yo'q.
Bu SaaS capstone 2 dagi "ro'yxat 500 ta" topilmasining egizagi. Testlar ko'rsatmadi, chunki ular 1–3 ta xabar bilan ishlaydi. Tuzatish ikki qismli. Birinchi ulanishda — oxirgi 200 ta (ORDER BY id DESC LIMIT 200, keyin teskari tartibga). Eskilari uchun esa kursor bilan sahifalash: GET /chat/xabarlar?oldin=<id> (Pagination: offset, cursor, keyset). Last-Event-ID yo'li o'zgarmaydi, lekin 200 dan ko'p o'tkazib yuborilgan bo'lsa, mijozga "yana bor" belgisi kerak.
5.3 Yana bir "teshik": tarix va obuna orasida
oqim() ning tartibiga qarang: avval tarix() (bazadan o'qish), keyin #obuna() (Redis kanaliga yozilish). Ular orasida bir necha millisekund o'tadi. Shu oraliqda boshqa nusxada yangi xabar yozilsa nima bo'ladi? U bazaga tarix o'qilgandan keyin tushdi, demak tarixda yo'q. U Redis'ga obunadan oldin e'lon qilindi, demak jonli ham kelmaydi. Undan keyin yangi xabar kelsa, vaziyat yomonlashadi: Last-Event-ID teshikdagi xabardan oshib ketadi va qayta ulanish ham uni qaytarmaydi.
Bu kod o'qishdan topildi, o'lchanmagan: oraliq juda qisqa, testda tasodifan tushishi qiyin. Lekin yuk oshgan sari ehtimol oshadi. Klassik yechim — tartibni almashtirish: avval obuna (kelganlar buferga), keyin tarix, keyin bufer (id bo'yicha takrorlar tashlanadi). 3-mashqda buni modellashtirasiz.
Tekshirib ko'ring: Teshikka tushgan xabarni mijoz qachon ko'radi — keyingi jonli xabar kelganda yoki qayta ulanishda?
Javob
Faqat qayta ulanishda (yoki sahifa yangilanganda). Keyingi jonli xabar kelganda ekranga faqat o'zi qo'shiladi. Brauzer Last-Event-ID sifatida eng oxirgi olgan id'ni eslaydi — u teshikdagi xabardan katta. Shuning uchun qayta ulanishda ham server id > oxirgi bo'yicha qidiradi va teshikdagi xabar yana tushib qoladi. Uni faqat to'liq tarix yuklash (sahifani yangilash) qaytaradi. Teshikni tartibni almashtirib yopish shuning uchun muhim.
5.4 Juft misol: RLS yordam bergan joy
O'qilmaganlar so'rovida ichki so'rov bor: SELECT xabar_id FROM oqildi WHERE foydalanuvchi_id = $1. Unda jamoa_id sharti yo'q. Foydalanuvchi ikki jamoada bo'lsa, ichki so'rov ikki qator qaytarishi va so'rov xato berishi kerak edi. Lekin xato yo'q: oqildi jadvalida RLS bor va u faqat joriy jamoa qatorlarini ko'rsatadi.
Bu yaxshimi? Natija to'g'ri, lekin to'g'riligi so'rovning o'zida emas, RLS siyosatida. Ertaga kimdir bu so'rovni RLS'siz kontekstga (masalan, admin hisobotiga) ko'chirsa, u buziladi. Qoida: RLS — ikkinchi himoya, birinchisi emas. So'rovning o'zida AND jamoa_id = $2 yozilsin.
5.5 Mijozning mijozId si — har safar yangi
Takror himoyasi faqat mijoz o'sha id bilan qayta yuborsa ishlaydi. Kanon web'ida esa har yuborishda crypto.randomUUID() yangidan yasaladi va avtomatik qayta yuborish yo'q. Foydalanuvchi "Yuborish" ni javobsiz qolgandan keyin qayta bossa — yangi id, yangi xabar, ekranda ikkita. Himoya serverda bor, mijozda ishlatilmagan. Kod o'qishdan, sinalmagan. Tuzatish: id matn kiritilganda yasalsin va muvaffaqiyatli javobgacha saqlansin.
5.6 Sinalmaganlar
- Brauzerda bir nechta tab va HTTP/1.1 ning 6 ulanish chegarasi.
- Mobil tarmoqda uzoq uzilish va IP almashishi.
EventSourcening haqiqiy qayta ulanishi — Playwright e2e chatni bir marta ochadi, uzilishni sinamaydi.- Xonalar, "yozmoqda" holati — kanonda yo'q.
6. Hujumchi nigohi
| Hujum | Qanday urinadi | jamoa javobi |
|---|---|---|
| Begona chatni o'qish | GET /jamoalar/7/chat/oqim (a'zo emas) |
404, oqim ochilmaydi |
| Boshqa nomidan yozish | muallif_id ni almashtirish |
kodda olinmaydi; RLS WITH CHECK |
| Saytlararo so'rov (CSRF) | boshqa saytdan POST |
Origin tekshiruvi — 403 |
| XSS | <script> li matn |
SSE'da JSON, React matnni qochiradi (escape) |
| Katta xabar | 1 MB matn | Zod — 2 000 belgi, bazada CHECK, nginx 64k |
Begona mijoz_id ni bloklash |
boshqa muallif id'sini yuborish | UNIQUE da muallif_id bor |
| Spam va ulanish to'plash | sekundiga yuzlab POST, minglab SSE |
chegara yo'q — keyingi darsda o'lchaymiz |
Oxirgi qator ochiq qoldi. Chat'da rate limit yo'q va bitta foydalanuvchi ochadigan SSE ulanishlar soni cheklanmagan. Bu Real-time capstone 2 ning mavzusi.
7. Ko'p uchraydigan xatolar
7.1 Avval e'lon, keyin bazaga yozish
Mijozlar ko'rgan xabar yo'qolishi mumkin. Avval COMMIT.
7.2 Takrorni "bormi? yo'q bo'lsa yoz" bilan tekshirish
Ikki so'rov orasida poyga. ON CONFLICT bitta so'rovda.
7.3 SSE sarlavhalarini yuborib, jim turish
Birinchi write gacha mijoz hech narsa olmaydi. retry: yoki izoh qatori darhol.
7.4 Tarixni ORDER BY id LIMIT N bilan
Eng eskilari keladi. Birinchi yuklash — oxirgilari, qolgani — kursor bilan.
7.5 Obunadan oldin tarix
Oraliqdagi xabar yo'qoladi. Avval obuna (bufer bilan), keyin tarix.
7.6 close hodisasini unutish
Yopilgan ulanishlar ro'yxatda qoladi — xotira oqishi va bekor yozuvlar.
8. Mashqlar
Mashqlar kurs/mashqlar/38/06-chat/ da. 2- va 3-mashq yechimlari Node 24.21.0 da tekshirilgan (biz ishga tushirdik).
1-mashq (oson): bo'shliqlarni to'ldiring
- Takroriy
POST(o'shamijozId) javobi — - Brauzer qayta ulanganda yuboradigan sarlavha —
Last-Event-___— - Kanonda SSE yurak urishi oralig'i, soniya —
- Xabar matnining eng katta uzunligi, belgi —
- O'qildi belgisini faqat oldinga siljitadigan SQL funksiyasi —
Yechim
- 200 — yangi xabar 201, takror esa o'sha xabar bilan 200.
- ID —
Last-Event-ID; server undan keyingilarini tarixdan beradi. - 15 —
setInterval(…, 15_000); izoh qatori: yurakproksi ulanishni yopmasligi uchun. - 2000 — Zod sxemasida va bazadagi
CHECKda. - greatest — eski id kelsa ham belgi orqaga qaytmaydi.
2-mashq (o'rta): SSE oqimini o'qish
SSE oqimi tarmoqdan bo'laklarda keladi: bitta hodisa ikki bo'lakka bo'linishi, bitta bo'lakda ikki hodisa bo'lishi mumkin. sseOquvchi() funksiyasini yozing: u har bo'lakni qabul qilib, tayyor hodisalar ro'yxatini qaytarsin. Bo'sh qator — hodisa chegarasi, : bilan boshlangan blok — izoh (tashlanadi). id, event, data, retry maydonlarini ajrating. Oxirida qayta ulanishda yuboriladigan Last-Event-ID ni chiqaring.
Ishora: tugallanmagan qismni keyingi bo'lakkacha qoldiq da saqlang (Server-Sent Events).
Yechim
// SSE oqimini bo'laklardan hodisalarga ajratish
function sseOquvchi() {
let qoldiq = "";
return function qabul(bolak) {
qoldiq += bolak;
const hodisalar = [];
let k;
while ((k = qoldiq.indexOf("\n\n")) >= 0) {
const blok = qoldiq.slice(0, k);
qoldiq = qoldiq.slice(k + 2);
if (blok.startsWith(":")) continue; // izoh — yurak urishi
const h = { event: "message", data: "" };
for (const qator of blok.split("\n")) {
const i = qator.indexOf(": ");
const kalit = qator.slice(0, i);
const qiymat = qator.slice(i + 2);
if (kalit === "id") h.id = qiymat;
else if (kalit === "event") h.event = qiymat;
else if (kalit === "data") h.data = qiymat;
else if (kalit === "retry") h.retry = Number(qiymat);
}
hodisalar.push(h);
}
return hodisalar;
};
}
const qabul = sseOquvchi();
const bolaklar = [
"retry: 3000\n\n",
'id: 41\nevent: xabar\ndata: {"id":41,"ma',
'tn":"Salom"}\n\n: yurak\n\n',
'event: oqildi\ndata: {"tur":"oqildi","xabarId":41}\n\n',
];
let oxirgiId = null;
for (const b of bolaklar) {
for (const h of qabul(b)) {
if (h.id !== undefined) oxirgiId = h.id;
const matn = `${h.event}: ${h.data}`;
console.log(h.retry ? `retry ${h.retry} ms` : matn);
}
}
console.log("qayta ulanishda Last-Event-ID:", oxirgiId);Konsolda:
retry 3000 ms
xabar: {"id":41,"matn":"Salom"}
oqildi: {"tur":"oqildi","xabarId":41}
qayta ulanishda Last-Event-ID: 41Ikkinchi bo'lak JSON'ning yarmida tugadi. Funksiya uni kutdi va uchinchi bo'lak bilan birlashtirdi. : yurak izohi hodisa sifatida chiqmadi. oqildi hodisasida id: yo'q, shuning uchun Last-Event-ID 41 da qoldi — kanon ham aynan shunday: faqat xabarlar raqamlanadi. Kanon testidagi o'quvchi ham shu tamoyilda ishlaydi. Soddalashtirish: haqiqiy SSE'da data: bir nechta qator bo'lishi mumkin va ular \n bilan birlashtiriladi, : dan keyingi bo'shliq esa ixtiyoriy.
3-mashq (qiyin): tarix va obuna orasidagi teshik
«Yana bir "teshik"» bo'limidagi poygani modellashtiring. Bazada 1 va 2-xabarlar bor. Qadamlar ketma-ket bajariladi: kanon tartibi — tarix, keyin boshqa nusxada 3-xabar yoziladi va e'lon qilinadi, keyin obuna, keyin 4-xabar. Tuzatilgan tartib — buferliObuna (e'lonlar buferga), 3-xabar, tarix, buferniTukat (id bo'yicha takrorlarni tashlab), 4-xabar. Har tartibda mijoz ko'rgan xabarlarni, yo'qolganlarni va tashlangan takrorlar sonini chiqaring.
Ishora: ko'rsatilgan id'lar uchun Set — takrorni aniqlashning eng oddiy yo'li.
Yechim
// tarix va jonli oqim orasidagi "teshik": qadamlar ketma-ket
function sinov(tartib) {
const baza = [1, 2]; // allaqachon yozilgan xabarlar (id)
const obunachilar = [];
const mijoz = [];
const ekran = new Set();
const korsat = (id) => {
if (ekran.has(id)) return "takror";
ekran.add(id);
mijoz.push(id);
return "yangi";
};
const elon = (id) => { // boshqa nusxa: COMMIT, keyin publish
baza.push(id);
for (const o of obunachilar) o(id);
};
let bufer = null;
let takror = 0;
const qadamlar = {
tarix: () => baza.slice().forEach(korsat),
obuna: () => obunachilar.push((id) => korsat(id)),
buferliObuna: () => {
bufer = [];
obunachilar.push((id) => (bufer ? bufer.push(id) : korsat(id)));
},
buferniTukat: () => {
for (const id of bufer) if (korsat(id) === "takror") takror++;
bufer = null;
},
xabar3: () => elon(3),
xabar4: () => elon(4),
};
for (const q of tartib) qadamlar[q]();
const yoq = [1, 2, 3, 4].filter((id) => !ekran.has(id));
const yoqMatn = yoq.join(", ") || "yo'q";
return `${mijoz.join(", ")}; yo'qolgan: ${yoqMatn};`
+ ` takror tashlandi: ${takror}`;
}
console.log("kanon (tarix → obuna):",
sinov(["tarix", "xabar3", "obuna", "xabar4"]));
const tuzatilgan = ["buferliObuna", "xabar3", "tarix",
"buferniTukat", "xabar4"];
console.log("tuzatilgan (obuna → tarix):", sinov(tuzatilgan));Konsolda:
kanon (tarix → obuna): 1, 2, 4; yo'qolgan: 3; takror tashlandi: 0
tuzatilgan (obuna → tarix): 1, 2, 3, 4; yo'qolgan: yo'q; takror tashlandi: 1Tuzatilgan tartibda 3-xabar ikki yo'ldan keldi: buferdan ham, tarixdan ham (u tarix o'qilishidan oldin COMMIT bo'lgan). Set ikkinchisini tashladi. Narxi — bufer va takror tekshiruvi. Lekin "yo'qolgan xabar" o'rniga "tashlangan takror" — har doim yaxshi almashinuv: takrorni mijoz ko'rmaydi, yo'qolgan xabarni esa hech kim tiklamaydi. Kanon web'idagi id bo'yicha takror tekshiruvi aynan shu yerda foydali bo'ladi.
9. O'zingiz qiling: chat moduli
- Sxema —
xabarlar(mijoz_id,UNIQUE),oqildi, RLS siyosatlari (WITH CHECKda muallif). - Yozish —
POST /chat/xabarlar: Zod,ON CONFLICTbilan bitta so'rov, 201/200, COMMIT'dan keyinPUBLISH. - Oqim —
GET /chat/oqim: rol tekshiruvi oqimdan oldin,retry:darhol, tarixLast-Event-IDdan,closeda tozalash. - O'qildi —
PUT /chat/oqildi(greatest), o'qilmaganlar soni. - Testlar — kanondagi: ikki nusxa, takror,
Last-Event-ID, o'qildi, begona 404. - Tuzatishlar — har biriga avval eski kodda yiqiladigan test:
- tarix: birinchi ulanishda oxirgi 200 ta;
?oldin=<id>kursori; test — 205 xabar, yangi ulanish 205-ni ko'rsin; - obuna tarixdan oldin, bufer va id bo'yicha takror tashlash (3-mashq);
- o'qilmaganlar so'rovida
jamoa_idsharti; - web:
mijozIdmatn kiritilganda yasalsin, xato bo'lsa o'sha id bilan qayta yuborilsin.
- tarix: birinchi ulanishda oxirgi 200 ta;
- Xonalar (ixtiyoriy) —
xonalarjadvali,xabarlar.xona_id, kanal…:chat:<jamoa>:<xona>. - "Yozmoqda…" (ixtiyoriy) — bazaga yozilmaydi:
POST /chat/yozmoqdafaqat Redis'ga e'lon, mijozda 3 s dan keyin o'chadi, serverda bir a'zo uchun sekundiga bittadan ko'p emas.
Yechim namunasi: tarixning oxirgi 200 tasi
Kanonda bu tuzatish yo'q. Yo'nalish — ichki so'rovda teskari tartib, tashqisida to'g'ri:
SELECT * FROM (
SELECT id, muallif_id, matn, yaratilgan_vaqt FROM xabarlar
WHERE jamoa_id = $1 AND ($2::bigint IS NULL OR id < $2)
ORDER BY id DESC LIMIT 200
) t ORDER BY id;$2 — kursor (?oldin=<id>): bo'lmasa — eng oxirgilari, bo'lsa — undan eskilari. (jamoa_id, id) indeksi bu so'rovni to'liq qamraydi. Javobga keyingiKursor: t[0]?.id qo'shing — mijoz "yana yuklash" tugmasini faqat u bo'lsa ko'rsatadi. Last-Event-ID yo'li (id > $1 ORDER BY id) o'zgarmaydi.
10. Real ishda
- Slack, Telegram, Discord — hammasida xabar avval saqlanadi, keyin tarqatiladi. Mijozda esa xabar darhol "yuborilmoqda" holatida paydo bo'ladi — mijoz identifikatori shu uchun.
- SSE yoki WebSocket tanlovi ko'pincha infratuzilmaga bog'liq: korporativ proksilar WebSocket'ni ba'zan to'sib qo'yadi, SSE esa oddiy HTTP sifatida o'tadi.
- Tarix sahifalash — har chatning birinchi masshtab muammosi. 200 ta xabarli test jamoasi va 50 000 ta xabarli haqiqiy jamoa — boshqa-boshqa dunyo.
- Intervyuda "chatni qanday loyihalaysiz?" savolida bitta mezon ajratib turadi: "qayta ulanishda nima bo'ladi?" ga aniq javob —
Last-Event-ID, takror himoyasi va obuna tartibi (Dizayn: chat).
Xulosa
- Chat =
POST(yozish) + SSE (o'qish); WebSocket kerak emas — mijoz kam yozadi, ko'p o'qiydi. - Xabar avval bazaga (COMMIT), keyin Redis'ga; takror —
mijoz_id+UNIQUE+ON CONFLICT, bitta so'rovda 201 yoki 200. Last-Event-IDo'tkazib yuborilganlarni tiklaydi; SSE sarlavhalari birinchiwritegacha ketmaydi —retry:darhol (15.6 s → 0.57 s).- O'qildi belgisi faqat oldinga (
greatest), RLS begona jamoa xabarini yopadi. - O'lchov: yangi ulanish eng eski 200 ta xabarni ko'radi; kod o'qish: tarix va obuna orasida teshik, mijoz
mijozIdni har safar yangilaydi.
Keyingi dars: Real-time capstone 2: masshtab, presence va bildirishnomalar — ikki nusxa va Redis, presence, yuk o'lchovi, rate limit va bildirishnomalar.
Manbalar
- WHATWG HTML — Server-sent events: https://html.spec.whatwg.org/multipage/server-sent-events.html (tekshirildi, 2026-11: qayta ulanishda
Last-Event-IDsarlavhasi; bir nechtadata:qatori\nbilan qo'shiladi;:dan keyingi bitta bo'shliq olib tashlanadi;:bilan boshlangan qator — izoh) - MDN — Using server-sent events: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events (tekshirildi, 2026-11: HTTP/2 siz chegara — brauzer va domen bo'yicha 6 ulanish;
retry— millisekundda) - Node.js —
response.flushHeaders()va sarlavhalar buferi: https://nodejs.org/api/http.html (tekshirildi, 2026-11) - PostgreSQL — INSERT … ON CONFLICT: https://www.postgresql.org/docs/current/sql-insert.html (tekshirildi, 2026-11)
- Kurs tajribasi (IlmHamroh, 2026-11):
jamoachati —test/chat.test.ts(ikki nusxa, bitta Redis),npm run check11/11; SSE sarlavhalari o'lchovi — ADR-0008. Tarix chegarasi — biz lokal production stack'ida o'lchadik (2026-11-10, 205 xabar); tarix va obuna orasidagi teshik va web'dagimijozId— kod o'qishdan, sinalmagan.
Izohlar · 0
Izoh yozish uchun kiring.