9.4-bob: Domain-Driven Design (DDD) asoslari

  DDD — murakkab domenni dasturda to'g'ri modellashtirish (Eric Evans 2003)
   Texnika emas, FIKRLASH usuli (biznes atrofida kod)

  QACHON DDD:
   Murakkab biznes mantiq (ko'p qoida, hisoblash, holat) — bank, sug'urta, logistika
   Uzoq yashaydigan, o'sadigan loyiha
   Biznes ekspertlari bilan yaqin ishlash

  QACHON EMAS:
   Oddiy CRUD (ma'lumot saqlash/o'qish — DDD ortiqcha)
   Kichik/qisqa muddatli loyiha

  UBIQUITOUS LANGUAGE — dasturchi + biznes egasi BIR XIL atamalar

   Texnik til (biznes tushunmaydi):
  UserManager.processData(), updateRecord(), DataProcessor

   Biznes tili (kod = biznes):
  Buyurtma.chegirmaQolla(), Mijoz.sodiqlikDarajasi(), YetkazibBerish.rejalashtir()

   Kod biznes hujjati bo'ladi (biznes egasi o'qiy oladi)
   Suhbat, kod, hujjat — bir xil atamalar

  STRATEGIK DDD (katta rasm — domenni bo'lish):
  - Bounded Context (chegaralangan kontekst — 2.4)
  - Ubiquitous Language 2.2-bob
  - Context Map (kontekstlar aloqasi)
  - Subdomain (core/supporting/generic)

  TAKTIK DDD (kod naqshlari — domenni modellash):
  - Entity 2.6-bob, Value Object 2.7-bob
  - Aggregate + Aggregate Root 2.8-bob, Repository 2.9-bob
  - Domain Event 2.10-bob, Domain Service 2.11-bob
  - Application Service (2.11a), Factory (2.11b)

  Strategik'da Context Map (2.4a) — kontekstlar aloqasi;
  Event Storming (2.13a) — modelni birga kashf qilish

  BOUNDED CONTEXT — domen modelining aniq chegarasi (o'z tili, qoidasi)

  Misol — "Mahsulot" turli kontekstda har xil:
  - Katalog konteksti: nom, tavsif, rasm, narx (ko'rsatish uchun)
  - Ombor konteksti: zaxira, joylashuv, og'irlik (saqlash uchun)
  - Buyurtma konteksti: narx, miqdor (sotib olish uchun)

   Bir "Mahsulot" yo'q — har kontekstda boshqa model (chegara)
   NestJS'da: har bounded context — alohida modul (8.1)

  CONTEXT MAP — bounded kontekstlar bir-biriga QANDAY bog'langani (jamoa + kod aloqasi)

   (yuqori oqim / upstream)  — model boshqasiga TA'SIR qiladi
   (quyi oqim / downstream)  — model boshqadan model OLADI

  Asosiy naqshlar:
  ┌──────────────────────┬─────────────────────────────────────────────────┐
  │ Partnership          │ ikki jamoa TENG — birga muvaffaqiyat/mag'lubiyat │
  │ Shared Kernel        │ umumiy KICHIK kod/model (birga egalik — ehtiyot) │
  │ Customer–Supplier    │ upstream (supplier) downstream (customer) ehtiyoji│
  │                      │ bilan HISOBLASHADI (rejalashtiradi)              │
  │ Conformist           │ downstream upstream modeliga BO'YSUNADI (ta'sir  │
  │                      │ yo'q — masalan tashqi API)                       │
  │ Anti-Corruption Layer│ downstream tarjimon qatlam bilan o'zini HIMOYA   │
  │  (ACL)               │ qiladi (tashqi model ichkariga kirmaydi)         │
  │ Open Host Service    │ upstream ochiq, hujjatlashtirilgan PROTOKOL/API  │
  │  (OHS)               │ beradi (ko'p iste'molchi uchun)                  │
  │ Published Language   │ umumiy, kelishilgan FORMAT (JSON schema, event)  │
  │                      │ — OHS ko'pincha shu til bilan gaplashadi         │
  └──────────────────────┴─────────────────────────────────────────────────┘

// ACL — tashqi to'lov provayderi modelini domenga kiritmaslik (himoya qatlami)
// Tashqi API xom javobi (o'zga model — bizniki bilan aloqasi yo'q)
interface StripeChargeResponse { id: string; amount_cents: number; currency: string; paid: boolean; }

// Anti-Corruption Layer — tashqi modelni BIZNING domen tiliga tarjima qiladi
export class TolovProvayderACL {
  constructor(private stripe: StripeClient) {}
  async tolovOl(buyurtmaId: string, summa: Pul): Promise<TolovNatijasi> {
    // tashqi (published language)  domen tili tarjimasi
    const javob: StripeChargeResponse = await this.stripe.charge({
      amount_cents: summa.miqdor * 100,
      currency: summa.valyuta.toLowerCase(),
    });
    // xom modelni domen value object'iga aylantirish (ichkariga "korrupsiya" o'tmaydi)
    return new TolovNatijasi(javob.id, javob.paid, new Pul(javob.amount_cents / 100, summa.valyuta));
  }
}
//  ACL yo'q bo'lsa: Stripe modeli butun domenga tarqaydi (provayder o'zgarsa — hamma joy buziladi)

  SUBDOMAIN turlari (biznes ahamiyatiga qarab):
  - Core domain: biznesning YURAGI (raqobat ustunligi — eng ko'p kuch)
     e-commerce: tavsiya tizimi, narxlash
  - Supporting: kerakli, lekin asosiy emas (o'rtacha kuch)
     buyurtma boshqaruvi
  - Generic: umumiy (tayyor yechim — kam kuch)
     auth, email, to'lov (tayyor servis)

   Core'ga eng ko'p e'tibor (DDD); generic'ni sotib ol/tayyor ishlat

// Entity — IDENTITY (o'ziga xoslik) bor, hayot sikli bor
class Mijoz {
  constructor(
    public readonly id: string,                       // IDENTITY (asosiy belgi)
    private ism: string,
    private sodiqlikBallari: number = 0,
  ) {}

  // Behavior-oriented (biznes xulqi, holat emas)
  ballQoshish(ball: number): void {
    if (ball < 0) throw new Error("Ball manfiy bo'lmaydi");
    this.sodiqlikBallari += ball;
  }
  sodiqDarajasi(): string {
    return this.sodiqlikBallari > 1000 ? "VIP" : "oddiy";   // biznes qoida
  }
}
// Ikki Mijoz — bir xil ism, lekin har xil ID  BOSHQA mijoz (identity)

// Value Object — IDENTITY YO'Q, faqat qiymat bilan aniqlanadi (o'zgarmas)
class Pul {
  constructor(
    public readonly miqdor: number,
    public readonly valyuta: string,
  ) {
    if (miqdor < 0) throw new Error("Pul manfiy bo'lmaydi");   // validatsiya
    Object.freeze(this);                              // o'zgarmas (immutable)
  }
  qoshish(boshqa: Pul): Pul {
    if (this.valyuta !== boshqa.valyuta) throw new Error("Valyuta mos emas");
    return new Pul(this.miqdor + boshqa.miqdor, this.valyuta);   // yangi obyekt
  }
  teng(boshqa: Pul): boolean {
    return this.miqdor === boshqa.miqdor && this.valyuta === boshqa.valyuta;   // qiymat tengligi
  }
}
// 100 UZS === 100 UZS (bir xil qiymat  TENG, ID yo'q)

// Aggregate — bog'liq obyektlar guruhi (bitta AGGREGATE ROOT orqali)
class Buyurtma {                                      // AGGREGATE ROOT
  private items: BuyurtmaItem[] = [];                 // ichki entity'lar (faqat root orqali)
  constructor(public readonly id: string, private status: string = "yangi") {}

  // Faqat root orqali o'zgartirish (yaxlitlik — invariant himoyasi)
  itemQoshish(mahsulotId: string, narx: Pul, miqdor: number): void {
    if (this.status !== "yangi") throw new Error("Faqat yangi buyurtmaga qo'shiladi");
    if (miqdor <= 0) throw new Error("Miqdor musbat bo'lsin");
    this.items.push(new BuyurtmaItem(mahsulotId, narx, miqdor));
  }
  jami(): Pul {
    return this.items.reduce((s, i) => s.qoshish(i.summa()), new Pul(0, "UZS"));
  }
}
class BuyurtmaItem {                                  // ichki entity (root orqali boshqariladi)
  constructor(public mahsulotId: string, private narx: Pul, private miqdor: number) {}
  summa(): Pul { return new Pul(this.narx.miqdor * this.miqdor, this.narx.valyuta); }
}

// Repository — AGGREGATE ROOT uchun (kolleksiya kabi — domen tilida)
interface BuyurtmaRepository {
  topById(id: string): Promise<Buyurtma | null>;     // aggregate qaytaradi
  saqla(buyurtma: Buyurtma): Promise<void>;          // butun aggregate
  mijozBuyurtmalari(mijozId: string): Promise<Buyurtma[]>;
}
//  Repository — aggregate root uchun (BuyurtmaItem uchun emas — u root orqali)
//  DB detali yashirin (9.2: 2.13, 9.3: 2.5 — port)

// Domain Event — domenda muhim narsa sodir bo'ldi (o'tgan zamon)
class BuyurtmaYaratildi {
  constructor(
    public readonly buyurtmaId: string,
    public readonly mijozId: string,
    public readonly sana: Date,
  ) {}
}

// Aggregate event chiqaradi
class Buyurtma {
  private events: any[] = [];
  static yarat(mijozId: string): Buyurtma {
    const buyurtma = new Buyurtma(crypto.randomUUID());
    buyurtma.events.push(new BuyurtmaYaratildi(buyurtma.id, mijozId, new Date()));   // event
    return buyurtma;
  }
  eventlarniOl() { return this.events; }
}
//  event'lar publish qilinadi (Observer — 9.2: 2.10)  email/SMS/statistika reaksiya

// Domain Service — bir entity'ga sig'maydigan biznes mantiq
class NarxlashXizmati {                               // domen service
  // Bir necha aggregate/qoida birga (entity'ga tegishli emas)
  chegirmaHisobla(buyurtma: Buyurtma, mijoz: Mijoz, aksiya: Aksiya): Pul {
    let chegirma = 0;
    if (mijoz.sodiqDarajasi() === "VIP") chegirma += 10;   // mijoz qoidasi
    if (aksiya.faolmi()) chegirma += aksiya.foiz;          // aksiya qoidasi
    const jami = buyurtma.jami();
    return new Pul(jami.miqdor * (1 - chegirma / 100), jami.valyuta);
  }
}
//  Bu mantiq Buyurtma'ga ham, Mijoz'ga ham tegishli emas  domain service

// Application Service — bitta USE-CASE'ni orkestratsiya qiladi (biznes qoidasi EMAS)
// Vazifasi: yuklash  domen chaqirish  saqlash  event publish (oqim boshqaruvi)
@Injectable()
export class BuyurtmaTasdiqlashUseCase {
  constructor(
    @Inject("BuyurtmaRepository") private repo: BuyurtmaRepository,   // port (2.9)
    private eventEmitter: EventEmitter2,
  ) {}

  async bajar(buyurtmaId: string): Promise<void> {
    const buyurtma = await this.repo.topById(buyurtmaId);   // 1. yuklash (infra)
    if (!buyurtma) throw new Error("Buyurtma topilmadi");
    buyurtma.tasdiqla();                                     // 2. DOMEN qoidasi (aggregate ichida)
    await this.repo.saqla(buyurtma);                         // 3. saqlash (infra)
    buyurtma.eventlarniOl().forEach((e) =>                   // 4. event publish
      this.eventEmitter.emit(e.constructor.name, e));
    buyurtma.eventlarniTozala();
  }
}
//  Application service'da biznes QOIDA YO'Q (tasdiqlash qoidasi Buyurtma.tasdiqla() ichida)
//  u faqat oqimni boshqaradi (yupqa qatlam)

// Factory — murakkab aggregate/VO yaratish mantiqini bir joyga jamlaydi
// (yaratish qoidalari konstruktordan murakkabroq bo'lganda)

// 1-shakl: static factory method (aggregate ICHIDA — eng ko'p ishlatiladigan)
class Buyurtma {
  private constructor(public readonly id: string, public readonly mijozId: string) {}
  // "yarat" — nomi biznes tilida (ubiquitous language), invariant + event bir joyda
  static yarat(mijoz: Mijoz, savat: SavatItem[]): Buyurtma {
    if (savat.length === 0) throw new Error("Bo'sh savatdan buyurtma yaratilmaydi");
    const b = new Buyurtma(crypto.randomUUID(), mijoz.id);
    savat.forEach((s) => b.itemQoshish(s.mahsulotId, s.narx, s.miqdor));
    b.events.push(new BuyurtmaYaratildi(b.id, mijoz.id, new Date()));
    return b;                                          // to'liq izchil (invariant) obyekt qaytadi
  }
  private events: any[] = [];
  itemQoshish(mahsulotId: string, narx: Pul, miqdor: number): void { /* ... */ }
}

// 2-shakl: alohida Factory klass (yaratish bir necha manba/qoidaga bog'liq bo'lsa)
class BuyurtmaFactory {
  constructor(private narxlash: NarxlashXizmati) {}
  aksiyadanYarat(mijoz: Mijoz, aksiya: Aksiya, savat: SavatItem[]): Buyurtma {
    // murakkab yaratish: aksiya narxini hisoblab, aggregate quradi
    const b = Buyurtma.yarat(mijoz, savat);
    // ...aksiyaga bog'liq qo'shimcha o'rnatishlar
    return b;
  }
}

  DDD + Clean 9.3-bob qatlamlari:
  ┌──────────────────────────────────────┐
  │ Presentation (controller — 9.3: 2.10) │
  ├──────────────────────────────────────┤
  │ Application (use-case — orkestratsiya) │   application service
  ├──────────────────────────────────────┤
  │ DOMAIN (entity, VO, aggregate,        │   DDD yuragi (taktik DDD)
  │   domain service, domain event, port) │
  ├──────────────────────────────────────┤
  │ Infrastructure (repo impl, DB)        │   driven adapter
  └──────────────────────────────────────┘
   DDD domen qatlamini boyitadi (Clean — struktura, DDD — domen modeli)

  NestJS modul 8.1-bob  bounded context 2.4-bob:
  src/
  ├── buyurtma/           Buyurtma bounded context (modul)
  │   ├── domain/             (entity, VO, aggregate, event, port — taktik DDD)
  │   ├── application/        (use-case)
  │   ├── infrastructure/     (repo impl)
  │   └── presentation/       (controller)
  ├── katalog/            Katalog bounded context (alohida modul)
  └── tolov/              To'lov bounded context

  Kontekstlar aloqasi: domain event (EventEmitter — 8.16) / module communication

  EVENT STORMING — domen ekspertlari + dasturchilar birga domenni MODELLASHTIRISH
  (Alberto Brandolini). Devor + rangli stiker qog'ozlar bilan ishlanadi.

  Rangli stiker "til"i (chapdan o'ngga vaqt oqimi bo'yicha):
   Domain Event   — o'tgan zamon fakti ("BuyurtmaTasdiqlandi") — asosiy element
   Command        — event'ni keltirib chiqargan harakat ("BuyurtmaniTasdiqla")
   Aggregate      — command qabul qilib, event chiqaradigan (Buyurtma)
   Policy         — "har safar X bo'lsa, Y qil" (event  keyingi command)
   Read Model     — qaror uchun kerakli ko'rinish
   Actor          — command yuboradigan foydalanuvchi/rol
   Hotspot        — nizoli/noaniq joy (ochiq savol)

   Natija: bounded context chegaralari 2.4-bob, aggregate'lar 2.8-bob,
    domain event'lar 2.10-bob TABIIY ravishda ko'rinadi

  DDD taktik bloklar  ilg'or naqshlarga tabiiy ulanadi (9.7-bob):

  Domain Event 2.10-bob ──┬── EVENT SOURCING: holatni SAQLASH o'rniga
                        │    event'lar KETMA-KETLIGI saqlanadi
                        │    (aggregate holati event'lardan qayta tiklanadi)
                        │
                        └── CQRS: buyruq (write — aggregate, invariant) va
                             so'rov (read — optimallashtirilgan read model)
                             modelini AJRATISH

  Aggregate 2.8-bob — CQRS'da WRITE tomoni (izchillik chegarasi)
  Read Model      — CQRS'da READ tomoni (denormallashgan, tez o'qish)

   DDD — murakkab domen uchun (oddiy CRUD'ga emas — 2.1):
  - Anemic model'dan qoch (entity faqat getter/setter — biznes mantiq service'da)
     DDD: biznes mantiq entity ichida (rich model — 2.6)
  - Lekin oddiy CRUD'ga DDD = over-engineering (9.3: 2.13)
  - Taktik DDD'siz strategik (ubiquitous language) ham qimmatli

  Qoida: domen murakkabligiga mos (core domen — DDD; generic — oddiy)

   Ubiquitous Language (kod = biznes tili — 2.2)
   Bounded Context (domenni bo'lish — modul — 2.4, 2.13)
   Core domen'ga DDD (generic — oddiy — 2.5)
   Entity (identity + biznes xulqi — rich model — 2.6)
   Value Object (qiymat, immutable — 2.7)
   Aggregate root (yaxlitlik, invariant himoyasi — 2.8)
   Repository — aggregate root uchun 2.9-bob
   Domain Event (loose coupling — 2.10, 9.7)
   Factory (murakkab aggregate — izchil yaratish — 2.11b)
   Application service yupqa (orkestratsiya, qoida yo'q — 2.11a)
   Context Map + ACL (tashqi integratsiya himoyasi — 2.4a)
   Kichik aggregate; tranzaksiya = 1 aggregate; ID orqali murojaat 2.8-bob
   Anemic model'dan qoch; oddiy CRUD'ga DDD emas (balans — 2.14)

// Entity 2.6-bob: identity + biznes xulqi
class Mijoz { constructor(public readonly id: string) {} ballQoshish() {} }

// Value Object 2.7-bob: qiymat, immutable
class Pul { constructor(readonly miqdor: number, readonly valyuta: string) { Object.freeze(this); } }

// Aggregate 2.8-bob: root orqali
class Buyurtma { private items = []; itemQoshish() {} }   // root

// Repository 2.9-bob: aggregate root uchun
interface BuyurtmaRepository { topById(id): Promise<Buyurtma>; saqla(b: Buyurtma); }

// Domain Event 2.10-bob: o'tgan zamon
class BuyurtmaYaratildi { constructor(readonly buyurtmaId: string) {} }

// Pul value object
export class Pul {
  constructor(public readonly miqdor: number, public readonly valyuta: string = "UZS") {
    if (miqdor < 0) throw new Error("Pul manfiy bo'lmaydi");
    Object.freeze(this);
  }
  qoshish(b: Pul): Pul {
    this.valyutaTekshir(b);
    return new Pul(this.miqdor + b.miqdor, this.valyuta);
  }
  kopaytir(koef: number): Pul { return new Pul(this.miqdor * koef, this.valyuta); }
  teng(b: Pul): boolean { return this.miqdor === b.miqdor && this.valyuta === b.valyuta; }
  private valyutaTekshir(b: Pul) {
    if (this.valyuta !== b.valyuta) throw new Error("Valyuta mos emas");
  }
}

// Email value object (validatsiya + tur xavfsizlik)
export class Email {
  constructor(public readonly qiymat: string) {
    if (!/^[^@]+@[^@]+\.[^@]+$/.test(qiymat)) throw new Error("Email noto'g'ri");
    Object.freeze(this);
  }
}
//  ibtidoiy (string) o'rniga ma'noli tur (validatsiya ichida — primitive obsession'dan qochish)

// Mijoz entity (identity + biznes xulqi — rich, anemic emas)
export class Mijoz {
  private constructor(
    public readonly id: string,
    private ism: string,
    private email: Email,                             // value object (Misol 1)
    private sodiqlikBallari: number = 0,
  ) {}

  static royxatdanOt(ism: string, email: string): Mijoz {
    if (ism.length < 2) throw new Error("Ism juda qisqa");   // biznes qoida
    return new Mijoz(crypto.randomUUID(), ism, new Email(email));
  }

  // Biznes xulqi (entity ichida — rich model)
  ballQoshish(ball: number): void {
    if (ball < 0) throw new Error("Ball manfiy bo'lmaydi");
    this.sodiqlikBallari += ball;
  }
  sodiqDarajasi(): "oddiy" | "kumush" | "VIP" {
    if (this.sodiqlikBallari >= 5000) return "VIP";
    if (this.sodiqlikBallari >= 1000) return "kumush";
    return "oddiy";
  }
  chegirmaFoizi(): number {
    return { oddiy: 0, kumush: 5, VIP: 10 }[this.sodiqDarajasi()];   // biznes qoida
  }
}

// Buyurtma aggregate (root — yaxlitlik himoyasi)
export class Buyurtma {
  private items: BuyurtmaItem[] = [];
  private events: any[] = [];

  private constructor(
    public readonly id: string,
    public readonly mijozId: string,
    private status: "yangi" | "tasdiqlangan" | "yetkazildi" | "bekor" = "yangi",
  ) {}

  static yarat(mijozId: string): Buyurtma {
    const b = new Buyurtma(crypto.randomUUID(), mijozId);
    b.events.push(new BuyurtmaYaratildi(b.id, mijozId, new Date()));   // domain event (2.10)
    return b;
  }

  // INVARIANT himoyasi (faqat root orqali)
  itemQoshish(mahsulotId: string, narx: Pul, miqdor: number): void {
    if (this.status !== "yangi") throw new Error("Faqat yangi buyurtmaga qo'shiladi");
    if (miqdor <= 0) throw new Error("Miqdor musbat bo'lsin");
    const mavjud = this.items.find((i) => i.mahsulotId === mahsulotId);
    if (mavjud) mavjud.miqdorOshir(miqdor);
    else this.items.push(new BuyurtmaItem(mahsulotId, narx, miqdor));
  }

  tasdiqla(): void {
    if (this.items.length === 0) throw new Error("Bo'sh buyurtma tasdiqlanmaydi");
    this.status = "tasdiqlangan";
    this.events.push(new BuyurtmaTasdiqlandi(this.id));
  }

  jami(): Pul {
    return this.items.reduce((s, i) => s.qoshish(i.summa()), new Pul(0, "UZS"));
  }
  eventlarniOl() { return [...this.events]; }
  eventlarniTozala() { this.events = []; }
}

class BuyurtmaItem {                                  // ichki entity (root orqali)
  constructor(public readonly mahsulotId: string, private narx: Pul, private miqdor: number) {}
  miqdorOshir(qancha: number) { this.miqdor += qancha; }
  summa(): Pul { return this.narx.kopaytir(this.miqdor); }
}

// Domain event'lar (o'tgan zamon — domain/events/)
export class BuyurtmaYaratildi {
  constructor(
    public readonly buyurtmaId: string,
    public readonly mijozId: string,
    public readonly sana: Date,
  ) {}
}
export class BuyurtmaTasdiqlandi {
  constructor(public readonly buyurtmaId: string) {}
}

// Use-case event'larni publish qiladi (Observer — 9.2: 2.10, NestJS — 8.16)
@Injectable()
export class CreateOrderUseCase {
  constructor(
    @Inject("BuyurtmaRepository") private repo: BuyurtmaRepository,
    private eventEmitter: EventEmitter2,             // NestJS event (8.16)
  ) {}
  async bajar(mijozId: string, items: any[]): Promise<Buyurtma> {
    const buyurtma = Buyurtma.yarat(mijozId);
    items.forEach((i) => buyurtma.itemQoshish(i.mahsulotId, new Pul(i.narx), i.miqdor));
    await this.repo.saqla(buyurtma);
    // Domain event'larni publish (loose coupling — email/SMS reaksiya qiladi)
    buyurtma.eventlarniOl().forEach((e) => this.eventEmitter.emit(e.constructor.name, e));
    buyurtma.eventlarniTozala();
    return buyurtma;
  }
}

// Narxlash domain service (bir necha aggregate qoidasi birga)
export class NarxlashXizmati {
  chegirmalanganNarx(buyurtma: Buyurtma, mijoz: Mijoz, aksiya?: Aksiya): Pul {
    const jami = buyurtma.jami();
    let foiz = mijoz.chegirmaFoizi();                 // mijoz qoidasi (Misol 2)
    if (aksiya?.faolmi()) foiz += aksiya.foiz;        // aksiya qoidasi
    foiz = Math.min(foiz, 30);                        // maks 30% (biznes qoida)
    return jami.kopaytir(1 - foiz / 100);
  }
}
//  Bu mantiq Buyurtma yoki Mijoz'ga yolg'iz tegishli emas  domain service

// Port (domain qatlamida)
export interface BuyurtmaRepository {
  topById(id: string): Promise<Buyurtma | null>;
  saqla(buyurtma: Buyurtma): Promise<void>;
  mijozBuyurtmalari(mijozId: string): Promise<Buyurtma[]>;
}

// Adapter (infrastructure — butun aggregate'ni saqlaydi)
@Injectable()
export class TypeOrmBuyurtmaRepository implements BuyurtmaRepository {
  constructor(@InjectRepository(BuyurtmaOrm) private repo: Repository<BuyurtmaOrm>) {}

  async saqla(buyurtma: Buyurtma): Promise<void> {
    const orm = this.toOrm(buyurtma);                 // domen aggregate  ORM (item'lari bilan)
    await this.repo.save(orm);                        // butun aggregate (root + items)
  }
  async topById(id: string): Promise<Buyurtma | null> {
    const orm = await this.repo.findOne({ where: { id }, relations: ["items"] });   // (8.4)
    return orm ? this.toDomain(orm) : null;           // ORM  domen aggregate
  }
  async mijozBuyurtmalari(mijozId: string) { return []; }
  private toOrm(b: Buyurtma): BuyurtmaOrm { return {} as any; }
  private toDomain(orm: BuyurtmaOrm): Buyurtma { return {} as any; }
}

  E-commerce bounded context'lar (har biri modul — 8.1):

  ┌──────────────┐  domain event   ┌──────────────┐
  │  Katalog     │ ───────────────│  Buyurtma    │
  │  (mahsulot:  │                  │  (mahsulot:  │
  │   tavsif,    │                  │   narx,      │
  │   rasm)      │                  │   miqdor)    │
  └──────────────┘                  └──────┬───────┘
                                           │ BuyurtmaYaratildi
                                    ┌──────▼───────┐
                                    │  To'lov      │
                                    │  Omborxona   │
                                    └──────────────┘

   Har kontekstda "Mahsulot" boshqa model (katalog: tavsif; buyurtma: narx)
   Aloqa: domain event 8.16-bob — loose coupling

  src/buyurtma/                     Buyurtma bounded context
  ├── domain/
  │   ├── buyurtma.aggregate.ts        (Misol 3)
  │   ├── buyurtma-item.entity.ts
  │   ├── pul.value-object.ts          (Misol 1)
  │   ├── narxlash.service.ts          (domain service — Misol 5)
  │   ├── events/buyurtma-yaratildi.ts (Misol 4)
  │   └── buyurtma.repository.ts       (PORT — Misol 6)
  ├── application/
  │   ├── create-order.use-case.ts     (Misol 4)
  │   └── handlers/                     (event handler'lar)
  ├── infrastructure/
  │   ├── typeorm-buyurtma.repository.ts  (Misol 6)
  │   └── buyurtma.orm-entity.ts
  ├── presentation/
  │   └── buyurtma.controller.ts
  └── buyurtma.module.ts               (DI — 9.3: Misol 5)

//  ANEMIC model (DDD emas — mantiq tashqarida)
class BuyurtmaAnemic {
  id: string; items: any[]; status: string;          // faqat ma'lumot (getter/setter)
}
class BuyurtmaServiceAnemic {
  itemQoshish(b: BuyurtmaAnemic, item: any) {         // mantiq service'da (tarqoq)
    if (b.status !== "yangi") throw new Error("...");
    b.items.push(item);
  }
}

//  RICH model (DDD — mantiq entity ichida)
class BuyurtmaRich {
  private items: any[] = [];
  itemQoshish(item: any) {                            // mantiq entity'da (markazlashgan)
    if (this.status !== "yangi") throw new Error("...");
    this.items.push(item);
  }
}
//  Rich: biznes qoida entity bilan birga (topish/o'zgartirish oson, izchil)

  DDD kerakmi? (qaror):

  Domen murakkabmi? (ko'p biznes qoida, hisoblash, holat)
  ├─ YO'Q (oddiy CRUD)  DDD KERAK EMAS (oddiy layered — 9.3, over-engineering)
  └─ HA  davom et:
     │
     Uzoq yashaydimi? Biznes ekspert bormi?
     ├─ YO'Q  strategik DDD (ubiquitous language — 2.2) yetadi
     └─ HA  to'liq DDD (strategik + taktik):
        - Core domen'ga 2.5-bob — to'liq taktik DDD
        - Generic (auth/email) — oddiy/tayyor (2.5)

   Eng muhim: ubiquitous language (deyarli har joyda foydali — 2.2)

 entity faqat getter/setter, mantiq service'da (2.14)
 rich model (biznes mantiq entity'da — 2.6)

 pul = number, email = string (validatsiya tarqoq)
 Value Object (Pul, Email — validatsiya ichida — 2.7)

 buyurtma.items.push() (invariant buzilishi — 2.8)
 buyurtma.itemQoshish() (root orqali)

 oddiy ma'lumotga aggregate/VO (over-engineering — 2.1)
 murakkab domen'ga DDD (balans — 2.14)

 processData(), DataManager (biznes tushunmaydi — 2.2)
 chegirmaQolla(), sodiqDarajasi() (biznes tili)