JavaScript Full-stackMa'lumotga kirish patternlari: Repository, Service layer, Unit of Work va DTO
JavaScript Full-stack · 36-qism. Arxitektura va system design

Ma'lumotga kirish patternlari: Repository, Service layer, Unit of Work va DTO

22 daqiqa10/44-dars

Qisqacha: Ma'lumotga kirish naqshlari biznes qoidasini SQL'dan ajratadi. Repository ma'lumot qayerda saqlanishini yashiradi, Data Mapper bazadagi qatorni domen obyektiga aylantiradi. Service layer ilova chegarasini belgilaydi, Unit of Work bir nechta yozuvni bitta tranzaksiyaga yig'adi. DTO esa chegaradan nima kirib-chiqishini cheklaydi. vazifalar-api da bu naqshlar to'liq faqat vazifalar modulida qo'llangan. O'lchov ko'rsatdi: SQL chaqiruvlarining atigi 35 foizi ombor klasslarida. Unit of Work'ning ikki nusxasi bor va ular bir-biridan farq qiladi. DTO tekshiruvi ham ikki xil uslubda yozilgan.

Bu darsda

  • Repository va Data Mapper'ni loyihadagi aniq kodda ajratasiz, Active Record bilan solishtirasiz.
  • SQL qayerda yashashini o'lchaysiz va Repository qayerda yo'qligini tushuntirasiz.
  • Service layer nima qilishi va nima qilmasligi kerakligini aniqlaysiz.
  • Unit of Work'ni tranzaksiya va outbox bilan bog'laysiz va ikki implementatsiyasidagi farqni topasiz.
  • Kirish va chiqish DTO'larini, Query object'ni o'z ishlarida ko'rasiz.

Oldin bilishingiz kerak: Repository naqshi va qatlamlar, Tranzaksiyalar NestJS'da, ORM, query builder va raw SQL, Zod va Standard Schema NestJS'da.

1. Nega bu kerak?

Repository naqshi va qatlamlar darsida VazifaOmbori ni qurdik: interfeys, token va beshta implementatsiya. Tranzaksiyalar NestJS'da darsida esa Unit of Work bilan tanishdik va /toplam dagi yarim yozuv xatosini tuzatdik. Bu dars ularni qaytadan o'rgatmaydi. Uning savoli boshqa: bu naqshlar butun loyihada qanchalik qo'llangan va qo'llanmagan joyda nima bor?

Martin Fowler "Patterns of Enterprise Application Architecture" (2002) kitobida ma'lumotga kirish uchun o'nlab naqsh tasvirlagan. Ularni bir savol birlashtiradi: biznes qoidasi va SQL bitta joyda bo'lsa nima bo'ladi? Bunda qoidani SQL'siz testlab bo'lmaydi. SQL o'zgarsa, qoida ham qayta tekshiriladi va bitta qoida bir nechta so'rovda takrorlanadi.

Bu darsda besh naqsh bor:

Naqsh Savol vazifalar-api da
Repository ma'lumot qayerda va qanday saqlanadi? VazifaOmbori + 5 implementatsiya
Data Mapper qator qanday domen obyektiga aylanadi? pg-ombor.ts va prisma-ombor.ts dagi vazifa(q)
Service layer ilova qanday amallarni taklif qiladi? VazifalarService
Unit of Work qaysi yozuvlar birga muvaffaqiyatli yoki birga bekor? #tranzaksiyada, egasiSifatida
DTO va Query object chegaradan nima o'tadi? Zod sxemalari, RoyxatSorovi, proyeksiya

Hayotiy o'xshatish: kutubxona. Kitobxon kitobni so'raydi, kutubxonachi uni omborxonadan olib beradi. Kitob qaysi javonda turibdi, kitobxon bilmaydi — bu ombor (repository). Kitob ichidagi kartochka katalog shakliga o'tkaziladi — xaritalash (mapper). Bitta formulyar bilan uchta kitob beriladi: hammasi yoki hech biri — bu unit of work. Kitobxonga esa kitobning o'zi emas, faqat ruxsat etilgan sahifalar nusxasi berilishi mumkin — bu DTO.

2. Repository va Data Mapper

2.1 Repository: domen tilida gaplashadigan interfeys

vazifalar/ombor.ts dagi VazifaOmbori sakkiz metodli interfeys: royxat, soni, ol, yarat, yangila, ochir, teglar va almashtirHammasi. U uch narsani yashiradi:

  • qayerda: xotira, JSON fayl, Postgres yoki Prisma — iste'molchi bilmaydi;
  • qanday: SQL, structuredClone yoki Prisma so'rovi;
  • xato tili: Postgres'ning 23505 kodi tashqariga chiqmaydi. yangila va ochir natija turi qaytaradi: { tur: "ok" }, { tur: "topilmadi" } yoki { tur: "konflikt", joriy }.

Oxirgi nuqta nozik. Optimistik qulfda versiya mos kelmasa, ombor xato tashlamaydi, konflikt qaytaradi. HTTP 412 ga uni xizmat aylantiradi. Ombor HTTP'ni bilmaydi, xizmat esa SQL kodlarini bilmaydi.

2.2 Data Mapper: qatordan obyektga

Repository ichida yana bir naqsh ishlaydi — Data Mapper. Bazadagi qator va domen obyektining shakli har xil:

Bazada (vazifalar jadvali) Domen (Vazifa turi)
yaratilgan_vaqt — timestamptz, JS'da Date yaratildi — ISO satr
id — bigint, pg uni satr qilib qaytaradi id — number
teglar — alohida vazifa_teglari jadvalida teglar — matndan ajratilgan massiv
ochirilgan_vaqt — yumshoq o'chirish domenda yo'q

pg-ombor.ts da bu ishni vazifa(q) funksiyasi qiladi. prisma-ombor.ts da ham xuddi shu nomli o'z funksiyasi bor, chunki Prisma bigint ni BigInt sifatida qaytaradi. Ikki xaritalovchi, bitta natija shakli — sakkiz omborning bitta shartnoma testidan o'tishi aynan shunga tayanadi (SOLID 2).

2.3 Active Record bilan solishtirish

Ikkinchi mashhur yondashuv — Active Record: obyekt o'zini o'zi saqlaydi. vazifa.matn = "…"; await vazifa.save(). TypeORM'ning BaseEntity i, Sequelize modellari, Rails'ning ActiveRecord'i shunday ishlaydi (ORM, query builder va raw SQL).

Active Record Data Mapper + Repository
kim saqlaydi obyektning o'zi (save()) alohida ombor
domen obyekti baza ulanishini biladi oddiy obyekt, bazasiz
boshlash tez: model yozildi — ishlaydi sekinroq: interfeys, mapper, ombor
test baza yoki mock kerak xotira ombori yetarli
mos keladi CRUD, qoidalari kam qoidalari ko'p, ombori almashadigan

vazifalar-api da Active Record yo'q. Prisma klienti uni taklif qilmaydi: prisma.vazifa.findMany() oddiy obyekt qaytaradi va unda save() yo'q. Kanonning tanlovi 25-qismdan beri ombor almashtirib kelinganidan kelib chiqqan: xotira, fayl, Postgres, Prisma, kesh. Active Record'da bu besh almashinuvning har biri domen kodini ham o'zgartirardi.

2.4 Query object va xaritalash — model

Ro'yxat so'rovi ham ma'lumot sifatida uzatiladi. RoyxatSorovi turi filtr, saralash, limit, sahifa va jami bayrog'idan iborat. Bu Fowler'ning Query Object naqshi: "nima kerak"ni obyekt sifatida bildirish, SQL emas. Controller HTTP query satrini sorov.ts dagi royxatSorovi() bilan shu obyektga aylantiradi. Ombor esa uni SQL'ga yoki xotiradagi filtrga o'giradi.

Xavfsizlikning muhim qismi shu o'girishda. Saralash maydoni SQL'ga ustun nomi sifatida tushadi, uni parametr qilib bo'lmaydi. Shuning uchun pg-ombor.ts da oq ro'yxat bor: USTUN lug'ati va Object.hasOwn tekshiruvi. Ikkala ishni — Query object'dan SQL va qatordan obyekt — paketsiz modelda ko'ramiz:

js
// Query object → SQL: ustunlar oq ro'yxatdan, qiymatlar parametr
const USTUN = { yaratildi: "v.yaratilgan_vaqt", matn: "v.matn" };

function sql(sorov, egasi) {
  const p = [egasi];
  const shart = ["v.egasi_id = $1", "v.ochirilgan_vaqt IS NULL"];
  if (sorov.filtr.bajarildi !== undefined) {
    p.push(sorov.filtr.bajarildi);
    shart.push(`v.bajarildi = $${p.length}`);
  }
  const tartib = sorov.saralash.map((s) => {
    if (!Object.hasOwn(USTUN, s.maydon)) {
      throw new Error(`oq ro'yxatda yo'q: ${s.maydon}`);
    }
    return `${USTUN[s.maydon]} ${s.kamayish ? "DESC" : "ASC"}`;
  });
  p.push(sorov.limit);
  return {
    matn: `WHERE ${shart.join(" AND ")} ORDER BY `
      + `${[...tartib, "v.id"].join(", ")} LIMIT $${p.length}`,
    p,
  };
}

// Data Mapper: bazadagi qator → domen obyekti
const vazifa = (q) => ({
  id: q.id, matn: q.matn, bajarildi: q.bajarildi,
  teglar: q.matn.match(/#\p{L}+/gu)?.map((t) => t.slice(1)) ?? [],
  yaratildi: q.yaratilgan_vaqt.toISOString(),
});

const s = { filtr: { bajarildi: false }, limit: 20,
  saralash: [{ maydon: "yaratildi", kamayish: true }] };
const { matn, p } = sql(s, 7);
console.log(matn);
console.log(JSON.stringify(p));
const qator = { id: 3, matn: "Non olish #uy", bajarildi: false,
  yaratilgan_vaqt: new Date("2026-11-09T05:00:00Z") };
console.log(JSON.stringify(vazifa(qator)));
try {
  sql({ ...s, saralash: [{ maydon: "parol" }] }, 7);
} catch (x) {
  console.log(x.message);
}

Konsolda:

text
WHERE v.egasi_id = $1 AND v.ochirilgan_vaqt IS NULL AND v.bajarildi = $2 ORDER BY v.yaratilgan_vaqt DESC, v.id LIMIT $3
[7,false,20]
{"id":3,"matn":"Non olish #uy","bajarildi":false,"teglar":["uy"],"yaratildi":"2026-11-09T05:00:00.000Z"}
oq ro'yxatda yo'q: parol

Foydalanuvchi qiymatlari SQL matniga tushmadi: matnda faqat $1, $2, $3, qiymatlar esa alohida massivda (Parametrli so'rovlar va SQL injection). Saralash maydoni oq ro'yxatdan o'tdi, parol esa rad etildi. Oxiriga doim v.id qo'shiladi — tartib barqaror bo'lsin, kursor sahifalash shunga tayanadi. Model soddalashtirilgan: kanondagi teg qoidasi raqam, pastki chiziq va apostrofni ham qamraydi (teglariniOl). Object.hasOwn esa constructor yoki __proto__ kabi kalitlar prototipdan kelmasligi uchun.

3. SQL qayerda yashaydi — o'lchov

Repository naqshi yaxshi ishlaydi. Lekin u loyihaning qancha qismini qamraydi? src/ dagi SQL chaqiruvlarini sanadik: pg ning .query(…) va Prisma'ning $queryRaw, $executeRaw. Har faylni uch turga ajratdik: ichida …Ombor… klassi bo'lsa — ombor, *.controller.ts — controller, qolgani — boshqa (Node 24.21.0, biz ishga tushirdik; skript mashq papkasida). Chiqishda ikki joyga qarang: har guruhdagi "SQL chaqiruvlari" soni va to'rtinchi qatordagi ombor ulushi:

text
ombor: fayllar 7, SQL chaqiruvlari 76, tranzaksiya 5
controller: fayllar 8, SQL chaqiruvlari 28, tranzaksiya 22
boshqa: fayllar 20, SQL chaqiruvlari 115, tranzaksiya 22
jami SQL chaqiruvlari 219; ombor ulushi 35%
eng ko'p: bildirishnoma/markaz.ts 24, vazifalar/pg-ombor.ts 21, auth/otp.ts 17, auth/mfa.ts 15, fayl/metama.ts 13, vazifalar/prisma-ombor.ts 11

Usul taqribiy: bitta .query( qatori bir nechta so'rov yuborishi ham, sikl ichida bo'lishi ham mumkin. Lekin taqsimotning shakli aniq.

Natijani halol o'qish. Kutilgani — SQL asosan omborlarda. Haqiqatda esa faqat 35 foizi u yerda. Qolgani ikki joyda:

  • Controller'lar — 8 fayl, 28 chaqiruv. Webhook, fayllar, bildirishnomalar, Telegram va navbat controller'lari SQL'ni to'g'ridan yozadi. Bu qatlamlarni chetlab o'tish. U alohida o'lchov bilan Qatlamli arxitektura darsida ko'riladi.
  • "Boshqa" — 20 fayl, 115 chaqiruv. Eng kattasi bildirishnoma/markaz.ts (24): bildirishnomalar markazi. U ham biznes qoidasini (qaysi kanal, soatlik limit, eskirgan manzil), ham SQL'ni bitta klassda saqlaydi. Fowler bu shaklni Transaction Script deb ataydi: har amal — bitta protsedura, ichida SQL va qoidalar birga.

Bu xato emasmi? Ko'pincha — yo'q. Transaction Script oddiy, o'qish oson va qoidalar kam bo'lganda Repository'dan arzon. Bildirishnomalar markazining ombori almashtirilmaydi — u faqat Postgres bilan ishlaydi va RLS'ga tayanadi. Repository naqshi o'zini oqlaydigan uchta shartdan (omborni almashtirish, bazasiz test, murakkab qoida) unda faqat oxirgisi qisman bor. Kanon Repository'ni u eng ko'p foyda bergan joyda qo'llagan — vazifalarda. Qolgan joyda sodda yo'lni tanlagan.

Narxi ham bor. markaz.ts ning qoidalarini (kanal tanlash, limit) haqiqiy Postgres'siz testlab bo'lmaydi. Bu qoidalar o'sib borsa, Repository'ga ajratish vaqti keladi.

Qarorni uchta savol bilan qabul qilish mumkin. Diagrammani yuqoridan pastga o'qing: birinchi "ha" javobi Repository'ga olib boradi.

flowchart TB
  S1{"Ombor almashadimi?"} -->|ha| R["Repository"]
  S1 -->|yo'q| S2{"Qoidalar ko'p va bazasiz test kerakmi?"}
  S2 -->|ha| R
  S2 -->|yo'q| S3{"Bir xil SQL ko'p joyda takrorlanadimi?"}
  S3 -->|ha| R
  S3 -->|yo'q| T["Transaction Script yetarli"]

vazifalar moduli birinchi savolda "ha" oladi: ombor besh marta almashgan. bildirishnoma/markaz.ts esa uchala savolda "yo'q" oladi — hozircha.

Yana bir kichik topilma: o'lchov paytida loyihada ikki xil FaylOmbori klassi chiqdi. Biri vazifalar/fayl-ombor.ts da — vazifalarni JSON faylda saqlaydigan ombor. Ikkinchisi fayl/s3.ts da — ilova fayllari uchun S3 ombori. Nomlar bir xil, ma'nosi butunlay boshqa. Ikkalasini bitta faylga import qilish kerak bo'lsa, birini qayta nomlash (import { FaylOmbori as S3Ombori }) kerak bo'ladi. Umumiy til (ubiquitous language) buzilishining kichik namunasi — bu mavzu DDD strategik darsida.

Tekshirib ko'ring: Jamoangiz bildirishnoma/markaz.ts ga Repository qo'shmoqchi: BildirishnomaOmbori interfeysi va PgBildirishnomaOmbori. Qanday dalil bu ishni oqlaydi?

Javob

Uchta dalildan kamida bittasi kerak. (1) Ombor almashadi — masalan, bildirishnomalar boshqa bazaga yoki navbat xizmatiga ko'chadi. (2) Qoidalarni bazasiz testlash kerak va ular ko'p — kanal tanlash, limit, eskirgan manzil, takrorni olib tashlash. Har biri hozir faqat Postgres bilan sinaladi. (3) SQL bir necha joyda takrorlanmoqda. Ikkinchi dalil eng kuchli: agar markaz.ts testlari sekin va mo'rt bo'lsa, Repository o'zini oqlaydi. Aks holda +2 fayl va bitta token foyda bermaydi.

4. Service layer

VazifalarService ilovaning vazifalar bilan bog'liq amallarini taklif qiladi: royxat, ol, yarat, yangila, almashtir, toplamYarat, ochir. Fowler ta'rifida Service layer — ilova chegarasi: unga controller ham, CLI (buyruq.ts) ham, testlar ham bir xil murojaat qiladi.

Xizmat nima qiladi:

  • biznes qoidalari: MAKS_VAZIFA = 1000 — ro'yxat to'lsa 409;
  • natija tarjimasi: ombordagi topilmadi → 404, konflikt → 412 (natija() funksiyasi);
  • egasini aniqlash: so'rov egasi CLS'dan, ombor — fabrikadan (Yaratuvchi patternlar);
  • hodisalar: har yozuvdan keyin emit (Xulq patternlari).

Va nima qilmaydi: HTTP sarlavhalarini (ETag, Location) bilmaydi, SQL yozmaydi, Zod sxemasini chaqirmaydi. Shuning uchun buyruq.ts dagi CLI eksport HTTP'siz ishlay oladi. U ctx.get(VazifalarService) ni oladi va kursor bilan ro'yxat so'raydi. Controller uchun yozilgan biror narsa unga kerak emas.

Xizmatda bir zaif joy bor: yarat avval soni({}) ni so'raydi, keyin yarat ni chaqiradi. Bu ikki alohida chaqiruv, demak ikki alohida tranzaksiya. Ikkita parallel so'rov ikkalasi ham 999 ni ko'rib, 1001-vazifani yaratishi mumkin. Xuddi shu "hisobla, keyin yoz" poygasi 35-qismda webhook obunalari limitida topilgan va advisory lock bilan tuzatilgan edi (Amaliyot: race condition'larni hal qilish). Vazifalar limitida esa lock yo'q. Buni biz kodni o'qib topdik, parallel yuk bilan tekshirmadik. Narxi kichik: limit — suiiste'molga qarshi yumshoq chegara, 1000 o'rniga 1001 xavfsizlik muammosi emas. Lekin chegara qat'iy bo'lishi kerak bo'lsa (masalan, to'lov tarifidagi limit), tekshiruv va yozuv bitta Unit of Work'da bo'lishi shart. Bunga ikki yo'l bor: foydalanuvchi bo'yicha advisory lock (webhook'dagidek) yoki bazaning o'zidagi cheklov — masalan, trigger hisoblagichi. Ikkinchisi ishonchliroq, chunki uni boshqa kod yo'li ham chetlab o'ta olmaydi.

5. Unit of Work

5.1 Kanondagi ko'rinishi

Fowler'ning to'liq Unit of Work naqshi o'zgargan obyektlarni kuzatadi va oxirida hammasini bitta tranzaksiyada yozadi. ORM'larda shunday: TypeORM'ning EntityManager i, Entity Framework'ning DbContext i. Kanonda soddaroq shakl bor: tranzaksiya chegarasi va kontekst bitta funksiyada.

Ikki implementatsiya bor:

PgOmbori.#tranzaksiyada umumiy/rls.ts dagi egasiSifatida
qayerda ishlatiladi vazifalar ombori ichida 11 faylda, 35 chaqiruv
BEGIN → set_config (RLS egasi) → COMMIT ha ha
outbox hodisasi o'sha tranzaksiyada ha (#hodisa → hodisaYoz) chaqiruvchiga bog'liq
ROLLBACK ning o'zi yiqilsa ulanish pool'ga qaytarilmaydi, yopiladi ulanish oddiy release() bilan qaytadi
olingan ulanishdagi error hodisasi tinglanadi tinglanmaydi

egasiSifatida ning izohida "PgOmbori.#tranzaksiyada bilan bir xil naqsh" deb yozilgan. Lekin jadvalning oxirgi ikki qatori farq qiladi. #tranzaksiyada da 26-qismdagi tuzatish bor: ROLLBACK muvaffaqiyatsiz bo'lsa (ulanish uzilgan), ulanish xato bilan bo'shatiladi va pool uni tashlaydi. Aks holda keyingi so'rov buzilgan ulanishga tushadi. Olingan ulanishning error hodisasiga ham tinglovchi qo'yilgan: usiz ulanish uzilsa, butun jarayon yiqilishi mumkin (bu ham avvalgi tajribada topilgan). egasiSifatida da ikkalasi ham yo'q.

Bu farqni kodni o'qib topdik. Uni bazani tranzaksiya o'rtasida uzib sinamadik. Lekin xulosa naqshlar uchun muhim: bitta naqsh ikki joyda alohida yozilgan va bittasi tuzatilgan, ikkinchisi yo'q. Asosiy tamoyillar darsidagi DRY aynan shu holat haqida. "Tranzaksiyani qanday to'g'ri ochish va yopish" — bitta bilim, ikki nusxada. To'g'ri yo'l: PgOmbori ham egasiSifatida ni ishlatsin, tuzatishlar esa bitta joyda bo'lsin.

5.2 Nega 35 marta?

egasiSifatida ni chaqiradigan 11 fayl — fayllar, bildirishnomalar, webhook, Telegram, navbat, AI kvota va qidiruv. Ularning hammasida Repository yo'q, shuning uchun Unit of Work bevosita controller yoki xizmatda ochiladi. fayl/fayl.controller.ts ning o'zida 11 ta chaqiruv bor.

Halol eslatma: kanondagi patternlar inventari egasiSifatida ni "50 joyda chaqiriladi" deb yozgan. Biz qayta sanadik va 35 chaqiruv chiqdi. Nom src/ da jami 50 marta uchraydi, lekin bunga 11 ta import qatori, funksiya ta'rifi va izohlar ham kiradi.

5.3 Unit of Work chegarasi qayerda

Tranzaksiyalar NestJS'da darsida chegara qayerda bo'lishi kerakligini ko'rdik: bitta biznes amali — bitta birlik. Kanonda vazifa yozuvi va uning outbox hodisasi bitta birlikda. pg-ombor.ts izohi buni aniq aytadi: "COMMIT bo'lmasa hodisa ham yo'q". Aks holda ikki xil buzilish bo'lardi: vazifa bor-u, hodisa yo'q (webhook yo'qoldi) yoki hodisa bor-u, vazifa yo'q (mijozga mavjud bo'lmagan vazifa haqida xabar ketdi). 3-mashqda shu birlikni modelda yozasiz.

Bitta POST /v1/vazifalar so'rovining yo'li:

sequenceDiagram
  participant C as Controller
  participant S as VazifalarService
  participant O as PgOmbori
  participant DB as Postgres
  C->>S: yarat(yangi)
  S->>O: soni({})
  O->>DB: BEGIN, set_config, SELECT count, COMMIT
  S->>O: yarat(yangi)
  O->>DB: BEGIN, set_config
  O->>DB: INSERT vazifalar
  O->>DB: INSERT outbox (hodisaYoz)
  O->>DB: COMMIT
  O-->>S: Vazifa (mapper orqali)
  S-->>C: Vazifa, keyin emit

Diagrammada ikki tranzaksiya ko'rinadi. Ikkinchisi — haqiqiy birlik: vazifa va outbox qatori birga. Birinchisi esa limit tekshiruvi uchun alohida o'qish. "Service layer" bo'limida aytilgan poyga aynan shu ikki tranzaksiya orasida yashaydi.

6. DTO: chegaradan nima o'tadi

6.1 Kirish DTO'lari — Zod

Kirish ma'lumotlari Zod sxemalari bilan tekshiriladi (Zod va Standard Schema NestJS'da). Turlar sxemadan chiqariladi. vazifa.ts da type YangiVazifa = z.output<typeof YangiVazifaSxemasi> va izohda: "tur qo'lda takrorlanmaydi". Bitta sxema uch ish qiladi: ish vaqtidagi tekshiruv, TypeScript turi va OpenAPI hujjati.

z.strictObject — oq ro'yxat: noma'lum maydon xato beradi. Bu "ommaviy tayinlash" (mass assignment) hujumiga qarshi. Mijoz egasiId yoki versiya ni yuborib, ularni o'zgartira olmaydi (Backend'dagi injection va mass assignment).

6.2 Ikki tekshiruv uslubi

Controller'larda Zod ikki xil uslubda ishlatiladi. Sanadik (grep, biz ishga tushirdik):

Uslub Misol Soni
deklarativ: @Body({ schema }), @Query, @Param vazifalar.controller.ts, auth.controller.ts 37
qo'lda: tekshir(Sxema, req.body, "body") webhook, fayl, bildirishnoma, navbat, ai 12

Qo'lda tekshiradigan controller'lar 29-qismda Express'da yozilgan va 30-qismda Nest'ga ko'chirilgan. webhook.controller.ts izohi buni aytadi: "SQL o'zgarmadi". Ko'chirishda tekshiruv ham Express uslubida qolgan. Ikkala yo'l ham xavfsiz — ikkalasi bir xil Zod sxemasini chaqiradi. Farq hujjatda va izchillikda: deklarativ sxema OpenAPI hujjatiga avtomatik tushadi, qo'lda chaqirilgani esa tushmaydi.

Bu "takrorlanadigan qaror". Yangi controller qaysi uslubda yozilishi kerak? Javob CONTRIBUTING.md da bo'lishi kerak, aks holda nusxa ko'chirilgan fayl uslubini belgilaydi.

6.3 Chiqish DTO'lari

Chiqishda DTO ikki ish qiladi: ichki maydonlarni yashiradi va mijoz so'raganini beradi.

  • korinish(q) (webhook.controller.ts) — bazadagi qatorni javob shakliga o'giradi: ketma_ket_xato → ketmaKetXato. Obuna siri esa javobga faqat yaratilganda bir marta qo'shiladi.
  • proyeksiya(v, maydonlar) (sorov.ts) — sparse fieldsets: ?fields=id,matn bo'lsa, faqat shu maydonlar. Ruxsat etilgan maydonlar ro'yxati Zod sxemasida. 2-mashqda shuni yozasiz.

Javobni serializatsiya qilish darsidagi class-transformer yondashuvidan farqi: kanon chiqish DTO'larini klass va dekorator bilan emas, oddiy funksiya bilan yozadi. Nima chiqishi — funksiya tanasida ko'rinadi.

6.4 Bitta sxema — uch iste'molchi

DTO'ning eng qimmat xatosi — uning nusxalari. Controller'da bitta tur, OpenAPI hujjatida ikkinchisi, frontend'da uchinchisi qo'lda yozilsa, ular albatta ajraladi. Kanonda bu muammo bitta manba bilan yechilgan. sxema.ts izohida uch iste'molchi sanalgan: ish vaqtidagi tekshiruv, TypeScript turi (z.infer) va JSON Schema (npm run sxema). OpenAPI hujjati ham shu sxemalardan yig'iladi. hujjat.ts izohiga ko'ra, Nest 12 Zod 4 sxemalarini konverter'siz OpenAPI 3.0 ga aylantiradi (Swagger: @nestjs/swagger).

Shuning uchun «Ikki tekshiruv uslubi» bo'limidagi farq faqat estetika emas. Deklarativ @Body({ schema }) sxemani hujjatga ham beradi. Qo'lda chaqirilgan tekshir() esa faqat tekshiradi, hujjatda bu yo'lning tanasi bo'sh qoladi. Hujjatdan mijoz kodi generatsiya qiladigan jamoa (openapi-typescript, orval) bu 12 ta joyda turni qo'lda yozishga majbur bo'ladi. Ya'ni bitta manba tamoyili aynan shu 12 joyda buziladi. DTO'larni rejalashtirganda savol shunday: bu sxemani kim o'qiydi va ularning hammasi bitta manbadan oladimi?

7. Loyihangizda tekshiring

Kod bu darsda o'zgarmaydi. O'z nusxangizda:

  1. SQL xaritasi. O'lchov skriptini ishga tushiring. Repository'siz eng katta 3 faylning har biri uchun "Repository kerakmi?" savoliga uchta dalil bo'yicha javob yozing.
  2. Bitta Unit of Work. #tranzaksiyada dagi ikki himoyani (ROLLBACK xatosida ulanishni tashlash, error tinglovchisi) egasiSifatida ga ko'chiring va PgOmbori ni unga o'tkazing. Bu loyihadagi eng foydali kichik refaktoring bo'lishi mumkin: 35 chaqiruv bir zumda himoyalanadi. Commit xabari, masalan:
text
fix(rls): egasiSifatida — buzilgan ulanish pool'ga qaytmasin
  1. DTO uslubi. 12 ta qo'lda tekshiruvni deklarativ uslubga o'tkazish rejasini yozing yoki ataylab qoldirish sababini CONTRIBUTING.md ga qo'shing.

8. Ko'p uchraydigan xatolar

8.1 Har jadvalga Repository

Repository qimmat naqsh. Uni almashinadigan ombor, bazasiz test yoki murakkab qoida uchun qo'llang. Sodda CRUD uchun Transaction Script yetarli.

8.2 Ombor HTTP yoki xato kodini qaytaradi

throw new NotFoundException() ombor ichida — qatlam chegarasi buzildi. Ombor domen natijasini qaytarsin, HTTP'ga xizmat yoki controller aylantirsin.

8.3 Tranzaksiya kodining nusxalari

BEGIN … COMMIT … ROLLBACK … release bloki bir necha joyda yozilsa, tuzatish birida qoladi. Bitta yordamchi funksiya.

8.4 Hodisa tranzaksiyadan tashqarida

Avval COMMIT, keyin hodisa yozuvi — orada jarayon qulasa, hodisa yo'qoladi. Outbox yozuvi o'sha birlikda.

8.5 Chiqishda butun obyektni qaytarish

return qator — bazadagi hamma ustun, ichki maydonlar bilan. Chiqish DTO'si yoki korinish() kabi funksiya.

8.6 Bir xil nomli, har xil ma'noli klasslar

Ikki FaylOmbori — biri vazifalarni JSON faylda saqlaydi, ikkinchisi S3'da ilova fayllarini. Kod review'da "FaylOmbori'ni o'zgartirdim" degan gap ikki xil tushuniladi va xato import oson. Nom vazifani aytsin: JsonVazifaOmbori, S3FaylOmbori. Qayta nomlash arzon, chalkashlik esa har o'qishda to'lanadi.

9. Mashqlar

Mashqlar kurs/mashqlar/36/10-malumot-kirish/ da. 2- va 3-mashq yechimlari Node 24.21.0 da tekshirilgan (biz ishga tushirdik). SQL o'lchovi skripti ham shu papkada.

1-mashq (oson): bo'shliqlarni to'ldiring

  • Bazadagi qatorni domen obyektiga aylantiradigan naqsh — Data
  • Obyektning o'zi save() qiladigan naqsh — Active
  • "Nima kerak"ni SQL emas, obyekt sifatida bildirish — Query
  • egasiSifatida chaqiruvlari soni —
  • SQL va biznes qoidasi bitta protsedurada — Transaction
Yechim
  • Mapper — pg-ombor.ts dagi vazifa(q).
  • Record — TypeORM BaseEntity, Sequelize; kanonda yo'q.
  • Object — RoyxatSorovi.
  • 35 — 11 faylda; nom esa 50 marta uchraydi (importlar va izohlar bilan).
  • Script — bildirishnoma/markaz.ts.

2-mashq (o'rta): chiqish DTO'si

maydonlarniOqi(fields) va proyeksiya(v, maydonlar) funksiyalarini yozing. Birinchisi ?fields= qiymatini vergul bo'yicha bo'ladi va har maydonni ruxsat etilganlar ro'yxati bilan tekshiradi — noma'lum maydon bo'lsa xato. Ikkinchisi obyektdan faqat shu maydonlarni oladi. Ombordan kelgan obyektda ichki egasiId maydoni bor — u hech qachon chiqmasligi kerak.

Ishora: Object.fromEntries juftliklar massividan obyekt yasaydi (Object.* metodlarining to'liq sharhi).

Yechim
js
// chiqish DTO: faqat ruxsat etilgan va so'ralgan maydonlar
const MAYDONLAR = ["id", "matn", "bajarildi", "teglar", "versiya"];

function maydonlarniOqi(fields) {
  const royxat = fields.split(",").map((m) => m.trim());
  const notogri = royxat.filter((m) => !MAYDONLAR.includes(m));
  if (notogri.length > 0) {
    throw new Error(`fields: noma'lum — ${notogri.join(", ")}`);
  }
  return royxat;
}

function proyeksiya(v, maydonlar) {
  return Object.fromEntries(maydonlar.map((m) => [m, v[m]]));
}

// ombordan kelgan obyektda ichki maydon ham bor (egasiId)
const v = { id: 3, matn: "Non #uy", bajarildi: false, teglar: ["uy"],
  versiya: 2, egasiId: 7 };

console.log(JSON.stringify(proyeksiya(v, maydonlarniOqi("id,matn"))));
console.log(JSON.stringify(proyeksiya(v, MAYDONLAR)));
try {
  maydonlarniOqi("id,egasiId");
} catch (x) {
  console.log(x.message);
}

Konsolda:

text
{"id":3,"matn":"Non #uy"}
{"id":3,"matn":"Non #uy","bajarildi":false,"teglar":["uy"],"versiya":2}
fields: noma'lum — egasiId

Ikkinchi qatorda fields berilmagan holat: hamma ruxsat etilgan maydon chiqdi, egasiId esa yo'q. DTO'ning asosiy ishi shu: ombor obyektini to'g'ridan qaytarsangiz, ertaga unga qo'shilgan ichki maydon ham tashqariga chiqadi. Kanonda proyeksiya maydonlar berilmasa obyektni o'zini qaytaradi, chunki Vazifa turida ichki maydon yo'q. Mashqdagi variant qat'iyroq. Maydon nomi includes bilan tekshirildi. Ro'yxat katta bo'lsa Set va has tezroq.

3-mashq (qiyin): Unit of Work va outbox

Soxta baza yozing: tranzaksiya(fn) ichidagi yozuvlar "qoralama"da yig'iladi va faqat fn muvaffaqiyatli tugasa haqiqiy jadvallarga o'tadi. Xato bo'lsa, qoralama tashlanadi. Shu baza ustida vazifaYarat(db, matn) ni yozing. U bitta birlikda vazifani va vazifa.yaratildi hodisasini outbox'ga yozadi. Matn 10 belgidan uzun bo'lsa, vazifa yozilgandan keyin xato tashlansin. Ikki chaqiruvdan keyin jadvallarda nechta qator borligini chiqaring.

Ishora: async funksiyadagi throw — rad etilgan Promise, uni try/catch va await ushlaydi (async / await).

Yechim
js
// soxta baza: tranzaksiya ichidagi yozuvlar COMMIT gacha "qoralama"
function baza() {
  const jadvallar = { vazifalar: [], outbox: [] };
  return {
    jadvallar,
    async tranzaksiya(fn) {
      const qoralama = { vazifalar: [], outbox: [] };
      try {
        const n = await fn({
          yoz: (j, qator) => qoralama[j].push(qator),
        });
        for (const j of Object.keys(qoralama)) {
          jadvallar[j].push(...qoralama[j]);
        }
        return n;
      } catch (x) {
        return `ROLLBACK (${x.message})`;
      }
    },
  };
}

// Unit of Work: vazifa va uning hodisasi — bitta birlik
function vazifaYarat(db, matn) {
  return db.tranzaksiya(async (t) => {
    t.yoz("vazifalar", { matn });
    if (matn.length > 10) throw new Error("matn juda uzun");
    t.yoz("outbox", { tur: "vazifa.yaratildi", matn });
    return "COMMIT";
  });
}

async function main() {
  const db = baza();
  console.log(await vazifaYarat(db, "Non olish"));
  console.log(await vazifaYarat(db, "Juda uzun vazifa"));
  const { vazifalar: v, outbox: o } = db.jadvallar;
  console.log(`vazifalar ${v.length}, outbox ${o.length}`);
}
main();

Konsolda:

text
COMMIT
ROLLBACK (matn juda uzun)
vazifalar 1, outbox 1

Ikkinchi chaqiruvda vazifa allaqachon "yozilgan" edi. Lekin xato butun birlikni bekor qildi: jadvallarda yarim qolgan vazifa ham, hodisasiz vazifa ham yo'q. Vazifalar va hodisalar soni doim teng — bu birlikning invarianti. Haqiqiy Postgres'da qoralamani baza o'zi saqlaydi: MVCC (ko'p versiyali parallel boshqaruv) tufayli tugallanmagan tranzaksiyaning yangi qatorlarini boshqa ulanishlar COMMIT'gacha ko'rmaydi. Bizning modelda u oddiy massiv. Kanondagi #tranzaksiyada va #hodisa aynan shu juftlik: hodisa hodisaYoz(c, …) bilan o'sha ulanish c orqali yoziladi. Boshqa ulanish orqali yozilsa, u boshqa tranzaksiyaga tushardi va invariant buzilardi.

10. Real ishda

  • ORM tanlovi — naqsh tanlovi. TypeORM ikkalasini qo'llaydi (Active Record va Data Mapper), Prisma va Drizzle esa Data Mapper'ga yaqin. Jamoada bitta yo'lni tanlang. Ikki uslub aralashgan loyihani o'qish qiyin.
  • "Generic repository" tuzog'i. Ombor<T> — findAll, findById, save bilan hamma jadvalga bitta interfeys. Bu domen tilini yo'qotadi va har iste'molchi baribir o'z so'rovini yozadi. Kanondagi VazifaOmbori domen tilida: teglar(), almashtirHammasi().
  • Unit of Work va mikroservislar. Bitta baza ichida tranzaksiya oddiy. Bir nechta xizmat bo'ylab esa yo'q — u yerda outbox va saga kerak (Saga).
  • DTO va API versiyalari. Chiqish DTO'si — API shartnomasi. Ichki model o'zgarsa ham, DTO o'zgarmasa, mijozlar buzilmaydi.
  • Intervyu savollari: "Repository va DAO farqi?", "Active Record'ning kamchiligi?", "Unit of Work nima uchun kerak?", "DTO va entity farqi?". Kuchli javob — loyihangizda naqsh qayerda qo'llanmaganini va nega ekanini aytish.
  • Repository va DAO farqi — eng ko'p so'raladigani. DAO (Data Access Object, ma'lumotga kirish obyekti) jadval tilida gapiradi: insertRow, findByColumn, bitta jadval — bitta DAO. Repository esa domen tilida: teglar(), almashtirHammasi(), va uning ichida bir nechta jadval bo'lishi mumkin (vazifalar va vazifa_teglari). VazifaOmbori — Repository, chunki iste'molchi jadval nomini umuman bilmaydi.

Xulosa

  • Repository domen tilida gaplashadi va SQL kodlarini tashqariga chiqarmaydi: topilmadi va konflikt — natija, HTTP emas. Data Mapper qatorni domen obyektiga aylantiradi: ikki omborda ikki xaritalovchi, natija shakli bitta.
  • Query object (RoyxatSorovi) va oq ro'yxat: qiymatlar parametr, ustun nomlari lug'atdan.
  • O'lchov: SQL chaqiruvlarining 35 foizi ombor klasslarida. Qolgani controller'lar (28) va Transaction Script shaklidagi xizmatlarda (115). Repository u eng ko'p foyda bergan joyda qo'llangan.
  • Service layer ilova chegarasi: qoida, natija tarjimasi, egasi va hodisalar. HTTP va SQL esa unda yo'q. soni va yarat orasidagi poyga limitni yumshoq qiladi.
  • Unit of Work'ning ikki nusxasi bor: #tranzaksiyada da 26-qism himoyalari bor, 35 marta chaqiriladigan egasiSifatida da esa yo'q. Bitta bilim — bitta joyda.
  • DTO: Zod bilan kirish (37 deklarativ, 12 qo'lda), funksiyalar bilan chiqish (korinish, proyeksiya).

Keyingi dars: Qatlamli arxitektura: controller → service → repository — 15 controller'ni o'lchaymiz: qaysilari xizmat orqali ishlaydi, qaysilari SQL'ni o'zi yozadi va "semiz controller" qayerda.

Manbalar

  • Martin Fowler — Patterns of Enterprise Application Architecture (2002) — Repository, Data Mapper, Active Record, Service Layer, Unit of Work, Data Transfer Object, Query Object, Transaction Script
  • Martin Fowler — Catalog of Patterns of Enterprise Application Architecture: https://martinfowler.com/eaaCatalog/ (tekshirildi, 2026-11 — darsdagi sakkiz naqshning hammasi katalogda bor)
  • node-postgres — Transactions ("tranzaksiyadagi hamma buyruq bitta klient orqali"): https://node-postgres.com/features/transactions (tekshirildi, 2026-11)
  • Kurs tajribasi (IlmHamroh, 2026-11): vazifalar-api 4.4.0 — vazifalar/ombor.ts, pg-ombor.ts, prisma-ombor.ts, sorov.ts, vazifalar.service.ts, umumiy/rls.ts, webhook.controller.ts; SQL joylari o'lchovi, egasiSifatida va tekshiruv uslublari sanog'i. Skript va mashq yechimlari — biz ishga tushirdik (Node 24.21.0, 2026-11-09).
36-qism. Arxitektura va system design · 10-dars yakunlandi

Ma'lumotga kirish patternlari: Repository, Service layer, Unit of Work va DTO

22 daqvaqt
0belgi
Keyingi dars: Qatlamli arxitektura: controller → service → repository va uning chegaralari
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0