JavaScript Full-stackReal-time capstone 1: chat arxitekturasi va xabarlar — SSE, takror himoyasi, tarix va o'qildi belgisi
JavaScript Full-stack · 38-qism. Yakuniy loyihalar (capstone)

Real-time capstone 1: chat arxitekturasi va xabarlar — SSE, takror himoyasi, tarix va o'qildi belgisi

25 daqiqa6/14-dars

Qisqacha: jamoa chati ikki yo'ldan iborat. Mijoz serverga oddiy POST bilan yozadi, server mijozga SSE oqimi orqali yuboradi. Xabar avval Postgres'ga yoziladi, keyin Redis kanaliga e'lon qilinadi. Takror yuborish mijozId bilan ushlanadi, uzilib qayta ulanish esa Last-Event-ID bilan 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 mijozId va UNIQUE bilan, o'tkazib yuborilganlarni Last-Event-ID bilan 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 UNIQUE kalitga muallif_id ham 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: xabar

Muallif 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):

sql
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):

ts
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):

sql
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:

js
// 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:

text
201 200 id: 1
Last-Event-ID: 1 → xabar 2, xabar 3
bazada: 3 ta xabar

Natija 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):

ts
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'da proxy_buffering off ham 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 olgan id: 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 oldin jamoalar.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):

sql
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:

sql
SELECT id, muallif_id, matn, yaratilgan_vaqt FROM xabarlar
WHERE id > $1 ORDER BY id LIMIT 200

Last-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):

text
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 ta

Ya'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.
  • EventSource ning 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'sha mijozId) 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 : yurak proksi ulanishni yopmasligi uchun.
  • 2000 — Zod sxemasida va bazadagi CHECK da.
  • 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
js
// 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:

text
retry 3000 ms
xabar: {"id":41,"matn":"Salom"}
oqildi: {"tur":"oqildi","xabarId":41}
qayta ulanishda Last-Event-ID: 41

Ikkinchi 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
js
// 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:

text
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: 1

Tuzatilgan 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

  1. Sxema — xabarlar (mijoz_id, UNIQUE), oqildi, RLS siyosatlari (WITH CHECK da muallif).
  2. Yozish — POST /chat/xabarlar: Zod, ON CONFLICT bilan bitta so'rov, 201/200, COMMIT'dan keyin PUBLISH.
  3. Oqim — GET /chat/oqim: rol tekshiruvi oqimdan oldin, retry: darhol, tarix Last-Event-ID dan, close da tozalash.
  4. O'qildi — PUT /chat/oqildi (greatest), o'qilmaganlar soni.
  5. Testlar — kanondagi: ikki nusxa, takror, Last-Event-ID, o'qildi, begona 404.
  6. 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_id sharti;
    • web: mijozId matn kiritilganda yasalsin, xato bo'lsa o'sha id bilan qayta yuborilsin.
  7. Xonalar (ixtiyoriy) — xonalar jadvali, xabarlar.xona_id, kanal …:chat:<jamoa>:<xona>.
  8. "Yozmoqda…" (ixtiyoriy) — bazaga yozilmaydi: POST /chat/yozmoqda faqat 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:

sql
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-ID o'tkazib yuborilganlarni tiklaydi; SSE sarlavhalari birinchi write gacha 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 mijozId ni 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

38-qism. Yakuniy loyihalar (capstone) · 6-dars yakunlandi

Real-time capstone 1: chat arxitekturasi va xabarlar — SSE, takror himoyasi, tarix va o'qildi belgisi

25 daqvaqt
0belgi
Keyingi dars: Real-time capstone 2: masshtab, presence va bildirishnomalar — Redis orqali ko'p nusxa, yuk o'lchovi va Redis uzilishi
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0