8.1-bob: NestJS kirish — arxitektura, modules, controllers, providers

  Tarixi:
  - 2017: Kamil Myśliwiec yaratdi
  - Maqsad: Angular arxitektura naqshlarini backend'ga olib kelish
  - "Progressive Node.js framework" (rivojlanuvchi)

  Falsafasi (4 ustun):
  1. Consistency  — bitta, to'g'ri yo'l (opinionated)
  2. Scalability  — modullar bilan o'sish (jamoa, kod)
  3. Testability  — DI + Jest (sinaladigan)
  4. Extensibility — plugin tizimi (ORM, GraphQL, microservices)

  NestJS (yuqori daraja — arxitektura, DI, dekorator)
        │
        ▼ (adapter)
  Express (yoki Fastify) — HTTP server 5.6-bob
        │
        ▼
  Node.js HTTP 5.5-bob

   NestJS Express'ni ALMASHTIRMAYDI — uning USTIDA (abstraksiya)
   Fastify adapter ham bor (tezroq — platformFastify)

import { NestFactory } from "@nestjs/core";
import {
  FastifyAdapter,
  NestFastifyApplication,
} from "@nestjs/platform-fastify";       // npm i @nestjs/platform-fastify
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter(),                // Express o'rniga Fastify
  );
  await app.listen(3000, "0.0.0.0");    // Fastify — host talab qiladi
}
bootstrap();

  Angular (frontend)          NestJS (backend) — bir xil g'oya:
  @Component                  @Controller (so'rovlarni qabul qiladi)
  @Injectable (service)      @Injectable (provider — biznes logika)
  @NgModule                  @Module (guruhlash)
  Dependency Injection       Dependency Injection 8.2-bob
  Dekorator + DI             Dekorator + DI

   Angular bilsangiz, NestJS mental modeli tanish

npm install -g @nestjs/cli            # CLI o'rnatish (global)

nest new loyiha-nomi                  # yangi loyiha (to'liq tuzilma)
nest generate module users            # modul (yoki: nest g module users)
nest g controller users               # controller
nest g service users                  # service (provider)
nest g resource users                 # TO'LIQ CRUD (module+controller+service+DTO+entity)

npm run start:dev                     # dev (watch — o'zgarishni kuzatadi)
npm run build                         # production build

  loyiha/
  ├── src/
  │   ├── main.ts                — entry (bootstrap — 2.10)
  │   ├── app.module.ts          — root modul 2.6-bob
  │   ├── app.controller.ts      — controller 2.7-bob
  │   ├── app.service.ts         — service/provider 2.8-bob
  │   └── users/                 — feature modul (har resurs alohida)
  │       ├── users.module.ts
  │       ├── users.controller.ts
  │       ├── users.service.ts
  │       ├── dto/               — DTO 8.5-bob
  │       └── entities/          — entity 8.3-bob
  ├── test/                      — e2e testlar 8.11-bob
  ├── nest-cli.json              — CLI sozlama
  └── tsconfig.json              — TS (7.1, dekorator yoqilgan — 7.6)

import { Module } from "@nestjs/common";
import { UsersController } from "./users.controller";
import { UsersService } from "./users.service";

@Module({
  imports: [],                  // boshqa modullar (bog'liqliklar)
  controllers: [UsersController], // bu modul controller'lari
  providers: [UsersService],    // bu modul provider'lari (servicelar)
  exports: [UsersService],      // boshqa modullarga ulashish
})
export class UsersModule {}

import { Controller, Get, Post, Body, Param } from "@nestjs/common";
import { UsersService } from "./users.service";

@Controller("users")            // route prefiks: /users
export class UsersController {
  constructor(private usersService: UsersService) {}   // DI — service inject (8.2)

  @Get()                        // GET /users
  hammasi() {
    return this.usersService.hammasi();
  }

  @Get(":id")                   // GET /users/:id
  bitta(@Param("id") id: string) {
    return this.usersService.bitta(+id);
  }

  @Post()                       // POST /users
  yarat(@Body() data: CreateUserDto) {
    return this.usersService.yarat(data);
  }
}

  @Get()    — o'qish (GET)
  @Post()   — yaratish (POST)
  @Put()    — to'liq almashtirish (PUT)
  @Patch()  — qisman yangilash (PATCH)
  @Delete() — o'chirish (DELETE)
  @All()    — barcha metod;  @Options()/@Head() — kamroq ishlatiladi

import {
  Controller, Get, Post, Put,
  Param, Query, Body, Headers, Req, Res, Ip, HostParam,
} from "@nestjs/common";
import { Request, Response } from "express";

@Controller("users")
export class UsersController {
  @Get(":id")
  bitta(
    @Param("id") id: string,              // yo'l parametri: /users/42  "42"
    @Query("full") full: string,          // query: ?full=true  "true"
    @Headers("authorization") auth: string, // sarlavha (5.7)
    @Ip() ip: string,                     // mijoz IP manzili
  ) {
    return { id, full, auth, ip };
  }

  @Put()
  almashtir(@Body() dto: CreateUserDto) {  // butun tanani (JSON) oladi
    return dto;
  }

  // @Param() — barchasini obyekt sifatida;  @Query() — barcha query obyekt
  @Get()
  filtr(@Query() query: Record<string, string>) {
    return query;                          // { page: "1", sort: "name" }
  }
}

import { Injectable } from "@nestjs/common";

@Injectable()                   // bu class — provider (DI uchun)
export class UsersService {
  private users = [];           // (DB — 8.3)

  hammasi() {
    return this.users;          // biznes logika
  }
  yarat(data: CreateUserDto) {
    const user = { id: Date.now(), ...data };
    this.users.push(user);
    return user;
  }
}

  So'rov oqimi (NestJS uchlik):
  HTTP so'rov  CONTROLLER (qabul, /users)
                   │ usersService.hammasi()  (DI — 8.2)
                   ▼
              PROVIDER/SERVICE (biznes logika)
                   │ DB so'rov 8.3-bob
                   ▼
              javob  CONTROLLER  HTTP javob

  MODULE — bularni guruhlaydi (UsersModule: controller + service)

// main.ts
import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create(AppModule);   // ilovani yaratish
  app.setGlobalPrefix("api");                          // /api prefiks
  app.useGlobalPipes(new ValidationPipe());            // global pipe (8.5)
  await app.listen(3000);                              // tinglash
}
bootstrap();

  Bootstrap ichki bosqichlari (promptda yo'q — muhim):
  1. NestFactory.create(AppModule) — root moduldan boshlash
  2. Module discovery — barcha modullarni skanerlash (imports daraxti)
  3. Dependency resolution — har provider instansiyalanadi (DI — 8.2)
  4. Dynamic modules (forRoot/register) — sozlanadi
  5. Lifecycle hooks (onModuleInit, onApplicationBootstrap — 2.15)
  6. app.listen — HTTP server (Express — 2.2) tinglaydi

  An'anaviy (qo'lda):
  const db = new Database();
  const service = new UserService(db);     // O'ZINGIZ yaratasiz/ulaysiz
  const controller = new UserController(service);

  NestJS (IoC — avtomatik):
  constructor(private service: UserService) {}   // FAQAT so'raysiz
   NestJS UserService'ni (va uning bog'liqliklarini) O'ZI yaratib beradi

  "Inversion of Control" — yaratish nazoratini SIZ emas, KONTEYNER qiladi

  HTTP so'rov 
  1. Middleware (5.6 — global/modul)
  2. Guards (auth/RBAC — 8.7)
  3. Interceptors (oldin — log/transform — 8.7)
  4. Pipes (validatsiya/transform — 8.5)
  5. CONTROLLER handler (route metod)
        Service (biznes logika)
  6. Interceptors (keyin — javobni o'zgartirish)
  7. Exception filters (xato bo'lsa — 8.7)
   HTTP javob

  Feature module — bitta xususiyat (UsersModule — 2.6)
  Shared module  — qayta ishlatiladigan (DatabaseModule — exports bilan)
  Global module  — hamma joyda (@Global — har joyga import qilmasdan)
  Dynamic module — sozlanadigan (forRoot/register — ConfigModule — 8.14)

// Dynamic module (sozlanadigan — 8.14)
@Module({})
export class ConfigModule {
  static forRoot(options): DynamicModule {   // sozlash bilan
    return { module: ConfigModule, providers: [...], global: true };
  }
}
// Ishlatish: ConfigModule.forRoot({ ... })

  DEFAULT (Singleton) — bitta instansiya, butun ilova (eng ko'p — tez)
  REQUEST — har so'rovga yangi instansiya (so'rovga xos ma'lumot)
  TRANSIENT — har inject'ga yangi instansiya

  @Injectable({ scope: Scope.REQUEST })
  export class RequestService {}

import { OnModuleInit, OnModuleDestroy } from "@nestjs/common";

@Injectable()
export class UsersService implements OnModuleInit, OnModuleDestroy {
  onModuleInit() {                // modul tayyor bo'lganda (DB ulanish — 8.3)
    console.log("UsersService tayyor");
  }
  onModuleDestroy() {             // ilova to'xtaganda (tozalash — 5.10)
    console.log("UsersService tozalanmoqda");
  }
}

  ┌──────────────┬──────────────────┬──────────────────┐
  │              │ Express 5.6-bob    │ NestJS           │
  ├──────────────┼──────────────────┼──────────────────┤
  │ Falsafa      │ minimalist/erkin │ opinionated/struktura│
  │ Arxitektura  │ qo'lda tashkil   │ majburiy (modul) │
  │ TypeScript   │ qo'shimcha       │ tug'ma (native)  │
  │ DI           │ yo'q (qo'lda)    │ tug'ma (IoC)     │
  │ O'rganish    │ oson             │ qiyinroq         │
  │ Kichik loyiha│  tez           │ ortiqcha         │
  │ Katta/jamoa  │ tartibsizlik xavfi│  izchil       │
  └──────────────┴──────────────────┴──────────────────┘

  @nestjs/config       — env/config 8.14-bob
  @nestjs/typeorm      — TypeORM 8.3-bob; @nestjs/mongoose — Mongoose 8.13-bob
  @nestjs/jwt, passport — auth 8.9-bob
  @nestjs/swagger      — API hujjat 8.8-bob
  @nestjs/cache-manager — Redis kesh 8.15-bob
  @nestjs/bullmq       — navbat 8.22-bob; @nestjs/schedule — cron
  @nestjs/microservices — mikroservis 8.18-bob; @nestjs/graphql 8.19-bob
  @nestjs/websockets   — WebSocket gateway 8.21-bob
  @nestjs/testing      — test (8.11)

  NestJS arxitektura SOLID/Clean'ni RAG'BATLANTIRADI (9):
  - SRP: controller (HTTP), service (biznes), repository (DB) — ajratilgan
  - DIP: interface + DI 8.2-bob — bog'liqlikni teskari aylantirish
  - Modularlik: feature modullar (kengaytiriladigan)
  - Testlanadigan: DI  mock oson 8.11-bob

   NestJS "to'g'ri arxitektura"ni qiyin emas, OSON qiladi

   CLI bilan generatsiya (nest g resource — izchil — 2.4)
   Controller yupqa (faqat HTTP); service qalin (biznes — 2.7, 2.8)
   Feature-based modullar (har resurs — modul — 2.5)
   Default singleton scope (REQUEST ehtiyot — 2.14)
   Global pipe/filter (main.ts — 2.10, 8.5)
   exports bilan ulashish (shared modul — 2.13)
   Lifecycle hooks (resurs boshqaruvi — 2.15)
   Request lifecycle'ni tushun (guard/pipe joyi — 2.12)

// Module (2.6)
@Module({ imports: [], controllers: [X], providers: [Y], exports: [Y] })
export class XModule {}

// Controller (2.7)
@Controller("users")
export class UsersController {
  constructor(private service: UsersService) {}   // DI (8.2)
  @Get() hammasi() {}  @Get(":id") bitta(@Param("id") id) {}  @Post() yarat(@Body() dto) {}
}

// Provider (2.8)
@Injectable() export class UsersService {}

// Bootstrap 2.10-bob: NestFactory.create(AppModule)  app.listen(3000)

nest new loyiha    nest g resource users    npm run start:dev

// main.ts — ilova kirish nuqtasi
import { NestFactory } from "@nestjs/core";
import { ValidationPipe } from "@nestjs/common";
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create(AppModule);   // root moduldan (2.10)

  app.setGlobalPrefix("api");                          // barcha route: /api/...
  app.useGlobalPipes(new ValidationPipe({             // global validatsiya (8.5)
    whitelist: true,                                   // DTO'da yo'q maydonni o'chir
    transform: true,                                   // tur'ga aylantirish
  }));
  app.enableCors();                                    // CORS (5.20)
  app.enableShutdownHooks();                           // lifecycle (2.15)

  await app.listen(3000);
  console.log("Server: http://localhost:3000/api");
}
bootstrap();

// app.module.ts — ildiz modul
import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";        // (8.14)
import { UsersModule } from "./users/users.module";
import { ProductsModule } from "./products/products.module";

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),          // global config (8.14, 2.13)
    UsersModule,                                        // feature modullar (2.5)
    ProductsModule,
  ],
})
export class AppModule {}
// Root modul — barcha feature modullarni birlashtiradi (modul daraxti — 2.6)

// users/users.module.ts
import { Module } from "@nestjs/common";
import { UsersController } from "./users.controller";
import { UsersService } from "./users.service";

@Module({
  controllers: [UsersController],    // HTTP qatlam (2.7)
  providers: [UsersService],         // biznes qatlam (2.8)
  exports: [UsersService],           // boshqa modullar uchun (2.13)
})
export class UsersModule {}

// users/users.controller.ts
import {
  Controller, Get, Post, Patch, Delete, Body, Param, Query, HttpCode, HttpStatus,
} from "@nestjs/common";
import { UsersService } from "./users.service";
import { CreateUserDto, UpdateUserDto } from "./dto";   // (8.5)

@Controller("users")                 // /api/users (global prefiks — 2.10)
export class UsersController {
  constructor(private readonly usersService: UsersService) {}   // DI (8.2)

  @Get()                             // GET /api/users
  hammasi(@Query("page") page = "1") {
    return this.usersService.hammasi(+page);
  }

  @Get(":id")                        // GET /api/users/:id
  bitta(@Param("id") id: string) {
    return this.usersService.bitta(+id);   // NotFound bo'lsa — 404 (8.7)
  }

  @Post()                            // POST /api/users
  @HttpCode(HttpStatus.CREATED)      // 201 (5.7)
  yarat(@Body() dto: CreateUserDto) {
    return this.usersService.yarat(dto);
  }

  @Patch(":id")                      // PATCH /api/users/:id
  yangila(@Param("id") id: string, @Body() dto: UpdateUserDto) {
    return this.usersService.yangila(+id, dto);
  }

  @Delete(":id")                     // DELETE /api/users/:id
  @HttpCode(HttpStatus.NO_CONTENT)   // 204
  ochir(@Param("id") id: string) {
    return this.usersService.ochir(+id);
  }
}
// Controller — yupqa: faqat HTTP, service'ga uzatadi (2.7)

// users/users.service.ts
import { Injectable, NotFoundException } from "@nestjs/common";
import { CreateUserDto, UpdateUserDto } from "./dto";

@Injectable()                        // provider (2.8)
export class UsersService {
  private users: any[] = [];         // (DB — 8.3)
  private idHisob = 1;

  hammasi(page: number) {
    return this.users.slice((page - 1) * 20, page * 20);   // sahifalash (5.7)
  }

  bitta(id: number) {
    const user = this.users.find((u) => u.id === id);
    if (!user) throw new NotFoundException(`${id}-foydalanuvchi topilmadi`);   // 404 (8.7)
    return user;
  }

  yarat(dto: CreateUserDto) {
    const user = { id: this.idHisob++, ...dto };
    this.users.push(user);
    return user;
  }

  yangila(id: number, dto: UpdateUserDto) {
    const user = this.bitta(id);     // topilmasa — 404 (qayta ishlatish)
    Object.assign(user, dto);
    return user;
  }

  ochir(id: number) {
    const user = this.bitta(id);
    this.users = this.users.filter((u) => u.id !== id);
  }
}
// NotFoundException — NestJS built-in exception 8.7-bob  avtomatik 404 JSON

import {
  NotFoundException,      // 404
  BadRequestException,    // 400
  UnauthorizedException,  // 401
  ForbiddenException,     // 403
  ConflictException,      // 409
} from "@nestjs/common";

@Injectable()
export class UsersService {
  yarat(dto: CreateUserDto) {
    const mavjud = this.users.find((u) => u.email === dto.email);
    if (mavjud) throw new ConflictException("Email band");   // 409 (5.7)
    // ...
  }
}
// NestJS xatoni AVTOMATIK to'g'ri HTTP javobga aylantiradi (5.10 — exception filter)

// Bir service boshqasini ishlatadi (DI — 2.11)
@Injectable()
export class EmailService {                          // (5.19)
  yubor(to: string, matn: string) { /* ... */ }
}

@Injectable()
export class UsersService {
  constructor(private emailService: EmailService) {} // DI — NestJS o'zi beradi (2.11)

  async yarat(dto: CreateUserDto) {
    const user = { id: 1, ...dto };
    await this.emailService.yubor(user.email, "Xush kelibsiz!");   // boshqa service
    return user;
  }
}
// EmailService UsersModule providers'ida yoki import qilingan modulda bo'lishi kerak (2.13)

import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";

@Injectable()
export class DatabaseService implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.ulanish();            // DB ulanish (modul tayyor bo'lganda — 8.3)
    console.log(" DB ulandi");
  }
  async onModuleDestroy() {
    await this.uzish();              // graceful shutdown (5.10)
    console.log("DB uzildi");
  }
  private async ulanish() { /* ... */ }
  private async uzish() { /* ... */ }
}

// database/database.module.ts — global (har joyda — 2.13)
import { Module, Global } from "@nestjs/common";
import { DatabaseService } from "./database.service";

@Global()                            // GLOBAL — har modulga import qilmasdan
@Module({
  providers: [DatabaseService],
  exports: [DatabaseService],        // ulashish
})
export class DatabaseModule {}
// Endi DatabaseService har joyda inject qilinadi (import shart emas — 2.13)

// To'liq oqim: Controller  Service  (boshqa Service)
@Controller("orders")
export class OrdersController {
  constructor(private ordersService: OrdersService) {}   // DI

  @Post()
  yarat(@Body() dto: CreateOrderDto) {
    return this.ordersService.yarat(dto);   // service'ga uzatadi (controller yupqa)
  }
}

@Injectable()
export class OrdersService {
  constructor(
    private usersService: UsersService,      // DI — boshqa service (2.11)
    private emailService: EmailService,      // DI
  ) {}

  async yarat(dto: CreateOrderDto) {
    const user = this.usersService.bitta(dto.userId);   // foydalanuvchi tekshir
    const order = { id: 1, ...dto };          // (DB — 8.3)
    await this.emailService.yubor(user.email, `Buyurtma #${order.id}`);   // (5.19)
    return order;
  }
}
// Qatlamlar: Controller (HTTP)  Service (biznes)  boshqa Service'lar (2.9, 9)

@Controller("users")
export class UsersController {
  constructor(private usersService: UsersService) {}

  @Get(":id")
  async bitta(@Param("id") id: string) {     // async — Promise (2.11-JS)
    return await this.usersService.bitta(+id);   // NestJS Promise'ni o'zi kutadi
  }
  // NestJS async handler'ni avtomatik qo'llab-quvvatlaydi (5.10: catchAsync kerak emas!)
}

{
  "scripts": {
    "start": "nest start",
    "start:dev": "nest start --watch",    // dev (o'zgarish kuzatuvi — 2.4)
    "start:debug": "nest start --debug --watch",
    "build": "nest build",                // production build
    "start:prod": "node dist/main",
    "test": "jest",                       // unit (8.11)
    "test:e2e": "jest --config ./test/jest-e2e.json"   // e2e (8.11)
  }
}

//  controller'da mantiq (qalin — 2.7)
@Post() yarat(@Body() dto) { /* validatsiya, DB, email... */ }

//  service'ga uzatish (controller yupqa)
@Post() yarat(@Body() dto) { return this.service.yarat(dto); }

//  DI ishlamaydi (2.8)
export class UsersService {}

//  @Injectable
@Injectable() export class UsersService {}

 service providers'da yo'q  "Cannot resolve dependencies" (2.6)
 @Module({ providers: [UsersService] })

//  qo'lda yaratish (DI buziladi, test qiyin — 2.11)
const service = new UsersService();

//  DI (constructor)
constructor(private service: UsersService) {}

 NestJS'da Express middleware'ni hamma joyda qo'lda (struktura buziladi)
 NestJS naqshlari (guard/pipe/interceptor — 8.7)