CQRS — Senior chuqurlik

Yechim — idempotency + checkpoint

Har projection o‘zining checkpointini (oxirgi qayta ishlangan event pozitsiyasi) yuritadi va allaqachon ko‘rgan eventni tashlab ketadi. Yozish esa upsert (takror ishlansa holat bir xil qoladi):

// IDEMPOTENT PROJECTION: event AT-LEAST-ONCE yetkaziladi (3-mavzu) -> takror kelishi mumkin
@EventsHandler(OrderCreatedEvent)
export class OrderProjection implements IEventHandler<OrderCreatedEvent> {
  async handle(e: OrderCreatedEvent) {
    const cp = await this.getCheckpoint('orderView');
    if (e.position <= cp) return;                  // allaqachon ishlangan -> SKIP

    // upsert (insert YOKI update) -> takror ishlansa ham xavfsiz, holat bir xil
    await this.prisma.orderView.upsert({
      where:  { orderId: e.orderId },
      create: { orderId: e.orderId, userId: e.userId, total: e.total, version: e.version },
      update: { total: e.total, version: e.version },
    });
    await this.saveCheckpoint('orderView', e.position);   // checkpoint'ni oldinga sur
  }
}

Nega bu super-kuch

Read model — "haqiqat" emas, balki eventlarning keshlangan ko‘rinishi. Demak:

• Projection’da bug bo‘lsa — tuzatib, read modelni qayta qurasan (ma’lumot yo‘qolmaydi).
• Yangi read model shakli kerak bo‘lsa — eski eventlarni qayta o‘ynatib, yangisini to‘ldirasan.
• Schema o‘zgarsa — yangi sxemaga qayta quriladi.

// REBUILD: read modelni NOLDAN qayta qurish (projection'da bug, yangi shakl, schema)
async rebuildOrderView() {
  await this.prisma.orderView.deleteMany();              // 1) eski read modelni tozala
  await this.resetCheckpoint('orderView');               // 2) checkpoint -> 0
  for await (const event of this.eventStore.readAll()) { // 3) HAMMA eventni qayta o'ynat
    await this.projection.handle(event);                 //    -> read model qaytadan quriladi
  }
}

Bir xil eventlar oqimidan bir nechta mustaqil projection o‘z read modelini quradi:

Real ilovalarda o‘qish yozishdan 10–100 barobar ko‘p. CQRS bilan bu nomutanosiblikni to‘g‘ridan-to‘g‘ri hal qilasan:

• Yozuv tomoni — izchillik uchun optimallashtiriladi: single-writer, transaksiya, kam nusxa.
• O‘qish tomoni — throughput uchun: ko‘p nusxa, kesh (4-mavzu), o‘qish replikasi (7-mavzu), hatto alohida sharding (6-mavzu) — yozuv modeliga tegmasdan.

Command validatsiya — ikki qatlam

1. Kirish validatsiyasi (DTO darajasi): maydonlar to‘g‘ri turdami, bo‘shmi (class-validator). 2. Biznes invariant (aggregat darajasi): "buyurtmani yopilganidan keyin o‘zgartirib bo‘lmaydi", "balans manfiy bo‘lmasin". Birinchisi shaklni, ikkinchisi qoidalarni tekshiradi.

Optimistic concurrency — yo‘qolgan yangilanish

Yechim — versiya bilan optimistik concurrency: yozishda kutilgan versiya o‘zgarmaganligini tekshir, o‘zgargan bo‘lsa rad et:

// OPTIMISTIC CONCURRENCY: ikki command bir aggregatni o'zgartirsa -> lost update
async execute(cmd: UpdateOrderCommand) {
  const order = await this.repo.findById(cmd.orderId);   // hozirgi version = 5
  order.applyChanges(cmd);                               // domen logikasi + invariant

  // YOZISHDA versiyani tekshir: kutilgan versiya o'zgarmaganda GINA yoz
  const res = await this.prisma.order.updateMany({
    where: { id: cmd.orderId, version: 5 },              // version hali 5 bo'lsa
    data:  { ...order.state, version: 6 },               // 6 ga oshir
  });
  if (res.count === 0)                                   // kimdir oraliqda o'zgartirdi
    throw new ConflictException('Concurrent update — qayta urin');
}

Foydalanuvchi lag’ni sezmasligi uchun

• Optimistik UI: foydalanuvchining o‘z amalini darhol ekranda ko‘rsat (server tasdig‘ini kutmasdan), fonda haqiqiy holatga moslashtir.
• Versioned read: command yangi versiya raqamini qaytaradi; o‘qishda read model shu versiyaga yetgunicha qisqa kut (yoki write model’dan fallback).
• "Pending" holat: "Buyurtmangiz qayta ishlanmoqda…" — foydalanuvchi nima bo‘layotganini biladi.
• Push/subscribe: projection yetib olganda WebSocket orqali "tayyor" signali yubor.

// VERSIONED READ: command yangi versiyani qaytaradi; o'qishda read model
// shu versiyaga yetgunicha biroz kutamiz (read-your-writes UX)
async getOrderView(orderId: string, minVersion: number) {
  for (let i = 0; i < 10; i++) {
    const view = await this.prisma.orderView.findUnique({ where: { orderId } });
    if (view && view.version >= minVersion) return view;   // projection yetdi -> ber
    await sleep(50);                                        // biroz kut (max ~500ms)
  }
  return this.readFromWriteModel(orderId);                  // fallback: write model'dan
}

Ular nima va nega mos

Event Sourcing (10-mavzu) — joriy holat o‘rniga barcha eventlarni haqiqat manbai sifatida saqlash. CQRS bilan birlashganda ideal:

• Yozuv tomoni = event oqimi (ES) — har o‘zgarish event sifatida saqlanadi.
• O‘qish tomoni = o‘sha eventlardan qurilgan projection’lar.
• Rebuild (2-bo‘lim) tabiiy bo‘ladi — eventlar allaqachon saqlangan. To‘liq audit/tarix bepul keladi.

To‘liq CQRS arxitekturasi — yig‘ma ko‘rinish

Senior tayyorlik cheklisti