9.1-bob: SOLID prinsiplari

  S — Single Responsibility  — bitta klass, bitta vazifa (bitta o'zgarish sababi)
  O — Open/Closed            — kengaytirishga ochiq, o'zgartirishga yopiq
  L — Liskov Substitution    — ota o'rniga bola qo'yilsa, buzilmasin
  I — Interface Segregation  — kichik, maxsus interfeyslar (katta umumiy emas)
  D — Dependency Inversion   — abstraksiyaga tayaning (konkretga emas)

  Maqsad: mo'rt, chalkash kod  moslashuvchan, test qilinadigan, oson o'zgaradigan

//  YOMON — User klassi ko'p vazifa (3 sabab o'zgaradi)
class User {
  constructor(public ism: string, public email: string) {}
  saqla() { /* DB mantiq */ }                        // 1. DB o'zgarsa
  emailYubor() { /* SMTP mantiq */ }                 // 2. Email o'zgarsa
  validatsiya() { /* tekshiruv */ }                  // 3. Qoida o'zgarsa
}

//  YAXSHI — har klass bitta vazifa
class User {                                          // faqat ma'lumot
  constructor(public ism: string, public email: string) {}
}
class UserRepository { saqla(user: User) {} }         // faqat DB (8.3)
class EmailService { yubor(user: User) {} }           // faqat email (8.10)
class UserValidator { tekshir(user: User) {} }        // faqat validatsiya (8.5)

  SRP buzilishi belgilari:
  - Klass nomida "And"/"Manager"/"Util" (ko'p vazifa)
  - Klass juda katta (500+ qator)
  - Bir o'zgarish ko'p joyni buzadi
  - Test qilish qiyin (ko'p narsani mock kerak)

  SRP foydasi:
   O'zgarish izolyatsiyasi (bir vazifa o'zgarsa, boshqasi tegmaydi)
   Qayta ishlatish (EmailService boshqa joyda ham)
   Test oson (bitta vazifa — bitta test)
   Jamoa (turli odam turli klass — to'qnashuv kam)

//  YOMON — yangi to'lov turi  mavjud kodni o'zgartirish (if qo'shish)
class TolovService {
  tolov(tur: string, summa: number) {
    if (tur === "click") { /* Click */ }
    else if (tur === "payme") { /* Payme */ }
    else if (tur === "uzum") { /* yangi  BU KODNI o'zgartirish kerak! */ }
  }
}

//  YAXSHI — interfeys + yangi klass (mavjud kod o'zgarmaydi)
interface TolovUsuli {
  tolov(summa: number): Promise<void>;
}
class ClickTolov implements TolovUsuli { async tolov(s: number) {} }
class PaymeTolov implements TolovUsuli { async tolov(s: number) {} }
class UzumTolov implements TolovUsuli { async tolov(s: number) {} }   // YANGI — eski tegmaydi!

class TolovService {
  async tolov(usul: TolovUsuli, summa: number) {       // abstraksiyaga tayanadi
    await usul.tolov(summa);
  }
}

  OCP qanday erishiladi:
  - Interfeys/abstrakt klass (kengaytirish nuqtasi)
  - Polimorfizm (2.10 — turli implementatsiya)
  - Strategy/Factory pattern 9.2-bob
  - Dependency Injection (8.2 — provider almashtirish)

   Hamma narsani OCP qilmang (YAGNI — kerak bo'lganda)
   o'zgarish ehtimoli yuqori joyda (to'lov, bildirishnoma turlari)

//  YOMON — bola ota shartnomasini buzadi
class Qush {
  ucha() { return "uchyapti"; }
}
class Pingvin extends Qush {
  ucha() { throw new Error("Pingvin ucholmaydi!"); }   // shartnoma buzildi!
}
function uchir(qush: Qush) { qush.ucha(); }            // Pingvin  xato!

//  YAXSHI — to'g'ri ierarxiya
class Qush {}
class UchadiganQush extends Qush { ucha() {} }
class Pingvin extends Qush { suzadi() {} }             // ucha() yo'q (to'g'ri model)

  LSP buzilish belgilari:
  - Bola metodi xato tashlaydi (ota qilmaydigan)
  - Bola metodi bo'sh (hech narsa qilmaydi)
  - Bolada "instanceof" tekshiruvi kerak bo'ladi
  - Bola ota shartlarini kuchaytiradi (qattiqroq talab)

  Qoida: meros (extends) — faqat haqiqiy "is-a" bo'lsa
   shubha bo'lsa, kompozitsiya (has-a) afzal (2.10)

  1) PRECONDITION (kirish sharti) KUCHAYTIRILMASLIGI kerak
      bola ota qabul qilgandan KO'PROQ talab qo'yolmaydi
      ota: har qanday son qabul qiladi; bola: faqat musbat son (kuchaytirdi)

  2) POSTCONDITION (chiqish sharti) SUSAYTIRILMASLIGI kerak
      bola ota va'da qilgandan KAMROQ narsa qaytarolmaydi
      ota: musbat natija va'da qiladi; bola: manfiy ham qaytaradi (susaytirdi)

  3) INVARIANT (o'zgarmas holat) va HISTORY (tarix) saqlanishi kerak
      bola ota holat qoidalarini buzmasligi kerak
      ota: immutable; bola: mutable qildi (invariant buzildi)

  Bonus (tip nazariyasi):
  - argument tiplari KONTRAVARIANT (kengroq bo'lishi mumkin)
  - qaytish tiplari KOVARIANT (torroq bo'lishi mumkin)
  - bola YANGI istisno (exception) TASHLAMASLIGI kerak

//  LSP buzilishi — bola PRECONDITION kuchaytiradi
class HisobRaqam {
  yechib(summa: number): void {
    // har qanday musbat summani yechishga ruxsat beradi
  }
}
class OmonatHisob extends HisobRaqam {
  yechib(summa: number): void {
    if (summa > 1000) {
      throw new Error("Omonat hisobdan 1000 dan ko'p yechib bo'lmaydi"); // qattiqroq talab!
    }
  }
}
// Kod `HisobRaqam` bilan ishlashga mo'ljallangan  OmonatHisob berilsa,
// kutilmagan xato: mijoz kodi 5000 yechmoqchi edi, ota ruxsat berardi, bola bermaydi.

//  To'g'ri — shartnoma buzilmaydi: cheklovni tur/model darajasida ifodala
interface Yechiladigan {
  yechibBerish(summa: number): { muvaffaqiyat: boolean; xabar?: string };
}
class OmonatHisob2 implements Yechiladigan {
  private limit = 1000;
  yechibBerish(summa: number) {
    if (summa > this.limit) {
      return { muvaffaqiyat: false, xabar: "Limitdan oshdi" }; // istisno emas — kutilgan natija
    }
    return { muvaffaqiyat: true };
  }
}

//  YOMON — katta umumiy interfeys (hamma majbur)
interface Ishchi {
  ishla(): void;
  ovqatlan(): void;
  uxla(): void;
}
class Robot implements Ishchi {
  ishla() {}
  ovqatlan() { throw new Error("Robot ovqatlanmaydi"); }   // majbur — kerak emas!
  uxla() { throw new Error("Robot uxlamaydi"); }
}

//  YAXSHI — kichik, maxsus interfeyslar
interface Ishlaydigan { ishla(): void; }
interface Biologik { ovqatlan(): void; uxla(): void; }
class Robot implements Ishlaydigan { ishla() {} }     // faqat kerakli
class Inson implements Ishlaydigan, Biologik {        // ikkalasi
  ishla() {} ovqatlan() {} uxla() {}
}

//  YOMON — yuqori modul konkret klassga bog'liq
class MySQLDatabase {
  saqla(data: any) {}
}
class UserService {
  private db = new MySQLDatabase();                    // konkret bog'liqlik (qattiq)
  yarat(user: any) { this.db.saqla(user); }           // MySQL'ga bog'langan!
}

//  YAXSHI — abstraksiyaga bog'liq (DI — 8.2)
interface Database {                                   // abstraksiya
  saqla(data: any): Promise<void>;
}
class MySQLDatabase implements Database { async saqla(d: any) {} }
class MongoDatabase implements Database { async saqla(d: any) {} }   // almashtirsa bo'ladi

class UserService {
  constructor(private db: Database) {}                 // abstraksiyaga (DI — 8.2)
  async yarat(user: any) { await this.db.saqla(user); }   // qaysi DB — farqi yo'q
}

  DIP — tamoyil (abstraksiyaga tayanish)
  DI (Dependency Injection) — uni amalga oshirish usuli 8.2-bob
  IoC konteyner — DI'ni avtomatlashtiruvchi (NestJS — 8.2)

  NestJS'da:
  constructor(private service: SomeService) {}    DI (DIP amalda)
  { provide: ABSTRACTION, useClass: Implementation }    abstraksiya almashtirish 8.2-bob

   Siz 8.2 da DIP'ni amalda ishlatgansiz (nomini bilmasdan)

  SOLID — alohida emas, BIRGALIKDA ishlaydi:
  - SRP klasslarni kichik qiladi  ISP interfeyslarni kichik
  - DIP abstraksiya  OCP kengaytirish  LSP almashtirish ishonchli
  - Hammasi  test oson (mock — 8.11), o'zgarish xavfsiz

  Natija: "Clean Architecture" 9.3-bob, DDD 9.4-bob — SOLID ustiga quriladi

  PATTERN 9.2-bob         QAYSI SOLID'NI AMALGA OSHIRADI
  ──────────────────────────────────────────────────────
  Strategy              OCP (yangi strategiya = yangi klass) + DIP
  Factory Method        OCP (yangi mahsulot = yangi factory) + DIP
  Abstract Factory      OCP + DIP (oila darajasida abstraksiya)
  Decorator             OCP (xulqni o'rashda kengaytirish) + SRP
  Adapter               DIP (mos kelmagan interfeyslarni ulash) + ISP
  Observer              OCP (yangi kuzatuvchi = yangi klass) + SRP
  Template Method       OCP (qadamlarni override) — LSP ehtiyot bilan
  Facade                ISP (murakkab tizimga sodda interfeys)
  Repository            DIP + SRP (ma'lumot kirishini abstraksiyalash)

   SOLID — qo'llanma, dogma emas:
  - Over-engineering (har narsaga interfeys — keraksiz murakkablik)
  - YAGNI ("You Aren't Gonna Need It" — kerak bo'lmaganni qilmaslik)
  - KISS ("Keep It Simple" — oddiylik afzal)

  Qoida: SOLID'ni MUAMMO bo'lganda qo'llang (o'zgarish, takror, test qiyinligi)
   kichik skript uchun SOLID shart emas; katta tizim uchun zarur

  HID                           QAYSI TAMOYIL BUZILGAN  DAVO
  ─────────────────────────────────────────────────────────────────
  God Object / katta klass      SRP   klassni vazifalarga ajratish
  Uzun metod (100+ qator)       SRP   mayda metodlarga bo'lish
  Katta switch/if-else zanjiri  OCP   polimorfizm / Strategy 9.2-bob
  Takroriy switch (bir xil tur) OCP   Factory + polimorfizm
  Bo'sh / throw qiluvchi metod  LSP/ISP  interfeys bo'lish / ierarxiya
  `instanceof` bilan shoxlanish  LSP   polimorfizm
  Ko'p metodli "fat" interfeys  ISP   mayda interfeyslarga bo'lish
  `new Concrete()` service ichida  DIP  konstruktor injection
  Import'lar juda ko'p (coupling) SRP/DIP  mas'uliyat va bog'liqlikni kamaytirish
  "Shotgun surgery" (bir        SRP   mas'uliyatni bir joyga jamlash
   o'zgarish  ko'p faylni tahrir)
  "Feature envy" (klass boshqa   SRP   mantiqni tegishli klassga ko'chirish
   klass ma'lumotini qazlaydi)

  1) TESTLAR bilan qopla (yoki mavjudligini tekshir)
      refactoring xulqni o'zgartirmasligini kafolatlaydigan to'siq
  2) HIDNI aniqla (2.12a jadvali) va qaysi tamoyil buzilganini belgila
  3) KICHIK qadam tanla:
     - Extract Method / Extract Class (SRP)
     - Introduce Interface + Replace Conditional with Polymorphism (OCP)
     - Replace Inheritance with Delegation/Composition (LSP)
     - Split Interface (ISP)
     - Dependency Injection kirit (DIP)
  4) BITTA qadamni bajar  testlarni ishga tushir  yashil bo'lsa commit
  5) Takrorla (2-qadamga qayt) — hid yo'qolguncha
  6) TO'XTA — muvozanat: yetarli darajaga yetganda to'xta (YAGNI — 2.12)

// interface — sof shartnoma (runtime'da yo'q — 7-qism)
interface Repository<T> { topById(id: number): Promise<T>; }

// abstract class — qisman implementatsiya + shartnoma (runtime'da bor)
abstract class BaseService {
  abstract bajar(): void;          // bola majburan implement qiladi
  protected log(m: string) {}      // umumiy xulq (meros)
}

// generics — LSP/ISP'ni tip darajasida ta'minlaydi (universal, tur-xavfsiz)
interface Oqiladigan<T> { topAll(): Promise<T[]>; }

// `implements` — bir klass BIR NECHA mayda interfeysni qo'shishi mumkin (ISP)
class ProductRepo implements Oqiladigan<Product>, Yoziladigan<Product> {}

   SRP — bir klass bir vazifa (controller/service/repo — 8.1)
   OCP — o'zgaruvchan joyda interfeys (to'lov, bildirishnoma — 2.4)
   LSP — meros faqat haqiqiy is-a (shubhada kompozitsiya — 2.7)
   ISP — kichik maxsus interfeys (katta umumiy emas — 2.8)
   DIP — abstraksiyaga tayaning (DI — NestJS — 2.9, 8.2)
   Sinergiya (birgalikda — test/o'zgarish — 2.11)
   Balans (YAGNI/KISS — over-engineering emas — 2.12)

// SRP 2.2-bob: bir klass bir vazifa
class UserRepository {}  class EmailService {}  class UserValidator {}

// OCP 2.4-bob: interfeys + yangi klass
interface TolovUsuli { tolov(s: number): Promise<void>; }
class UzumTolov implements TolovUsuli {}   // eski o'zgarmaydi

// LSP 2.6-bob: bola ota o'rniga ishlaydi (shartnoma buzilmaydi)
// ISP 2.8-bob: kichik interfeyslar
interface Ishlaydigan { ishla(): void; }

// DIP 2.9-bob: abstraksiyaga tayaning (DI)
constructor(private db: Database) {}   // interfeys, konkret emas

//  YOMON — OrderService hamma narsa qiladi
class OrderService {
  yarat(data: any) {
    // validatsiya + narx hisoblash + DB + email + log — 5 vazifa!
  }
}

//  YAXSHI — har vazifa alohida (NestJS — 8.1)
class OrderValidator {                                 // 1. validatsiya (8.5)
  tekshir(data: CreateOrderDto): void {}
}
class PriceCalculator {                                // 2. narx
  hisobla(items: Item[]): number { return 0; }
}
class OrderRepository {                                 // 3. DB (8.3)
  async saqla(order: Order): Promise<Order> { return order; }
}
class OrderNotifier {                                   // 4. xabar (8.10)
  async xabarBer(order: Order): Promise<void> {}
}

class OrderService {                                   // orkestratsiya (yupqa)
  constructor(
    private validator: OrderValidator,
    private calculator: PriceCalculator,
    private repository: OrderRepository,
    private notifier: OrderNotifier,
  ) {}
  async yarat(data: CreateOrderDto): Promise<Order> {
    this.validator.tekshir(data);
    const summa = this.calculator.hisobla(data.items);
    const order = await this.repository.saqla({ ...data, summa } as Order);
    await this.notifier.xabarBer(order);
    return order;
  }
}

// Yangi kanal qo'shish — mavjud kod o'zgarmaydi (OCP)
interface XabarKanali {
  yubor(qabuluvchi: string, matn: string): Promise<void>;
}

class EmailKanal implements XabarKanali {              // (8.10)
  async yubor(email: string, matn: string) { /* SMTP */ }
}
class SmsKanal implements XabarKanali {                // (5.18)
  async yubor(tel: string, matn: string) { /* Eskiz */ }
}
class TelegramKanal implements XabarKanali {           // (8.12)
  async yubor(chatId: string, matn: string) { /* bot */ }
}
class PushKanal implements XabarKanali {               // YANGI — eski tegmaydi!
  async yubor(token: string, matn: string) { /* FCM */ }
}

class XabarService {
  constructor(private kanallar: XabarKanali[]) {}      // ko'p kanal (DIP — 2.9)
  async hammaga(qabuluvchi: string, matn: string) {
    await Promise.all(this.kanallar.map((k) => k.yubor(qabuluvchi, matn)));
  }
}
// Yangi kanal: PushKanal yoz + ro'yxatga qo'sh  XabarService o'zgarmaydi

//  YOMON — Kvadrat Kvadratdan meros (LSP buzadi)
class Tortburchak {
  constructor(protected en: number, protected boy: number) {}
  enQoy(en: number) { this.en = en; }
  boyQoy(boy: number) { this.boy = boy; }
  yuza() { return this.en * this.boy; }
}
class Kvadrat extends Tortburchak {
  enQoy(en: number) { this.en = en; this.boy = en; }   // boy ham o'zgaradi — kutilmagan!
}
// uzunlik=5, balandlik=4 kutilsa  Kvadrat 4×4 (LSP buzildi)

//  YAXSHI — umumiy abstraksiya (meros emas)
interface Shakl {
  yuza(): number;
}
class Tortburchak2 implements Shakl {
  constructor(private en: number, private boy: number) {}
  yuza() { return this.en * this.boy; }
}
class Kvadrat2 implements Shakl {
  constructor(private tomon: number) {}
  yuza() { return this.tomon ** 2; }
}

//  YOMON — katta repository interfeysi
interface Repository<T> {
  topAll(): Promise<T[]>;
  topById(id: number): Promise<T>;
  yarat(data: T): Promise<T>;
  yangila(id: number, data: T): Promise<T>;
  ochir(id: number): Promise<void>;
  qidirText(matn: string): Promise<T[]>;              // hamma model'ga kerak emas
  aggregate(): Promise<any>;                           // faqat ba'zilarga
}

//  YAXSHI — kichik, kerakli interfeyslar
interface Oqiladigan<T> {
  topAll(): Promise<T[]>;
  topById(id: number): Promise<T>;
}
interface Yoziladigan<T> {
  yarat(data: T): Promise<T>;
  yangila(id: number, data: T): Promise<T>;
  ochir(id: number): Promise<void>;
}
interface Qidiriladigan<T> {
  qidir(matn: string): Promise<T[]>;
}
// Faqat o'qiladigan repo (read-only — masalan, hisobot)
class ReportRepository implements Oqiladigan<Report> {
  async topAll() { return []; }
  async topById(id: number) { return {} as Report; }
}
// To'liq CRUD + qidiruv
class ProductRepository implements Oqiladigan<Product>, Yoziladigan<Product>, Qidiriladigan<Product> {
  /* hamma metod */
}

// Abstraksiyalar (yuqori daraja shular ga tayanadi)
interface UserRepository {
  topByEmail(email: string): Promise<User | null>;
  saqla(user: User): Promise<User>;
}
interface PasswordHasher {
  hash(parol: string): Promise<string>;
  tekshir(parol: string, hash: string): Promise<boolean>;
}
interface TokenService {
  yarat(payload: object): string;
}

// Yuqori daraja — FAQAT abstraksiyalarga tayanadi (DIP)
class AuthService {
  constructor(
    private users: UserRepository,                    // interfeys
    private hasher: PasswordHasher,                    // interfeys
    private tokens: TokenService,                      // interfeys
  ) {}
  async login(email: string, parol: string): Promise<string> {
    const user = await this.users.topByEmail(email);
    if (!user || !(await this.hasher.tekshir(parol, user.parolHash))) {
      throw new Error("Email yoki parol noto'g'ri");   // (8.9)
    }
    return this.tokens.yarat({ sub: user.id });
  }
}

// Implementatsiyalar (past daraja — abstraksiyani amalga oshiradi)
class TypeOrmUserRepository implements UserRepository { /* TypeORM — 8.3 */ }
class BcryptHasher implements PasswordHasher { /* bcrypt — 5.15 */ }
class JwtTokenService implements TokenService { /* JWT — 8.9 */ }

//  AuthService TypeORM/bcrypt/JWT'ni BILMAYDI (almashtirsa bo'ladi, test oson — mock)

// NestJS — SOLID amalda
// DIP — interfeys token (8.2)
export const USER_REPOSITORY = Symbol("USER_REPOSITORY");

interface IUserRepository {                            // abstraksiya (DIP, ISP)
  topById(id: number): Promise<User>;
}

@Injectable()
class UsersService {                                  // SRP — faqat user biznes mantiq
  constructor(
    @Inject(USER_REPOSITORY) private repo: IUserRepository,   // DIP (8.2)
  ) {}
  bitta(id: number) { return this.repo.topById(id); }
}

// Module — implementatsiyani bog'lash (OCP — almashtirsa bo'ladi)
@Module({
  providers: [
    UsersService,
    { provide: USER_REPOSITORY, useClass: TypeOrmUserRepository },   // yoki MongoUserRepository
  ],
})
export class UsersModule {}
//  DB almashtirsa: faqat useClass o'zgaradi (UsersService tegmaydi — DIP+OCP)

// Chegirma strategiyalari (OCP — yangi chegirma  yangi klass)
interface ChegirmaStrategiyasi {
  hisobla(summa: number): number;
}
class ChegirmaYoq implements ChegirmaStrategiyasi {
  hisobla(s: number) { return s; }
}
class FoizChegirma implements ChegirmaStrategiyasi {
  constructor(private foiz: number) {}
  hisobla(s: number) { return s * (1 - this.foiz / 100); }
}
class VipChegirma implements ChegirmaStrategiyasi {   // YANGI
  hisobla(s: number) { return s > 1000000 ? s * 0.8 : s * 0.9; }
}

class Savatcha {
  constructor(private chegirma: ChegirmaStrategiyasi) {}   // strategiya (DIP)
  yakuniyNarx(summa: number) { return this.chegirma.hisobla(summa); }
}
// new Savatcha(new VipChegirma()) — yangi strategiya, Savatcha o'zgarmaydi (OCP)

// SOLID buzilish belgilari va tuzatish:

//  SRP buzilishi: "UserManager" (Manager = ko'p vazifa — 2.3)
//   User, UserRepository, UserValidator, UserNotifier

//  OCP buzilishi: katta switch/if (yangi tur  o'zgartirish — 2.4)
//   Strategy/Factory pattern (interfeys)

//  LSP buzilishi: override metod throw qiladi (2.6)
//   ierarxiyani qayta ko'rib chiq / kompozitsiya

//  ISP buzilishi: implements'da bo'sh/throw metodlar (2.8)
//   interfeysni bo'lish

//  DIP buzilishi: "new ConcreteClass()" service ichida (2.9)
//   constructor injection (DI)

//  Meros muammosi (LSP xavfi)
class Massiv extends Array {}                          // murakkab, kutilmagan xulq

//  Kompozitsiya (has-a — "composition over inheritance")
class Stack<T> {
  private items: T[] = [];                             // has-a (massivga ega)
  push(item: T) { this.items.push(item); }
  pop(): T | undefined { return this.items.pop(); }
  get size() { return this.items.length; }
}
//  faqat kerakli metodlar (ISP), kutilmagan meros yo'q (LSP), aniq (SRP)

// E-commerce buyurtma — barcha SOLID birga
interface IOrderRepository { saqla(o: Order): Promise<Order>; }          // DIP, ISP
interface IPaymentGateway { tolov(summa: number): Promise<boolean>; }    // DIP, OCP
interface IInventory { kamaytir(items: Item[]): Promise<void>; }         // DIP, ISP
interface INotifier { yubor(order: Order): Promise<void>; }              // DIP, ISP

// SRP — faqat buyurtma orkestratsiyasi
class CreateOrderUseCase {
  constructor(
    private orders: IOrderRepository,
    private payment: IPaymentGateway,                  // Click/Payme/Uzum almashtirsa bo'ladi (OCP)
    private inventory: IInventory,
    private notifier: INotifier,
  ) {}

  async bajar(dto: CreateOrderDto): Promise<Order> {
    const tolovOk = await this.payment.tolov(dto.summa);   // qaysi to'lov — farqi yo'q (DIP)
    if (!tolovOk) throw new Error("To'lov amalga oshmadi");
    await this.inventory.kamaytir(dto.items);
    const order = await this.orders.saqla(dto as any);
    await this.notifier.yubor(order);                  // qaysi kanal — farqi yo'q (OCP)
    return order;
  }
}
//  Test: barcha bog'liqlik mock 8.11-bob; o'zgarish lokal; kengaytirish xavfsiz
//  Bu — Clean Architecture use-case 9.3-bob ga ko'prik

 UserManager (login + email + DB + log — SRP buzilishi)
 ajratilgan klasslar (har biri bir vazifa — 2.2)

 if (tur === "yangi") (OCP buzilishi — 2.4)
 interfeys + yangi klass (Strategy)

 this.db = new MySQLDatabase() (DIP buzilishi — 2.9)
 constructor(private db: Database) (DI)

 ucha() { throw } (LSP buzilishi — 2.6)
 to'g'ri ierarxiya / kompozitsiya

 oddiy skriptga 10 ta interfeys (YAGNI buzilishi — 2.12)
 muammo bo'lganda SOLID (balans)