Custom dekoratorlar NestJS'da: createParamDecorator, applyDecorators va Reflector.createDecorator

@Patch(":id")
@JsonTana()
@UseInterceptors(VazifaSarlavhalariInterceptor)
yangila(
  @Param({ schema: IdSxemasi }) { id }: Id,
  @Body({ schema: OzgarishSxemasi }) body: VazifaOzgarishi,
  @Req() req: Request,
): Promise<Vazifa> {
  return this.xizmat.yangila(id, body, ifMatch(req));
}

/** Sarlavhadan joriy foydalanuvchi (demo: X-Foydalanuvchi) */
const JoriyFoydalanuvchi = createParamDecorator(
  (maydon: 'id' | 'ism' | undefined, ctx: ExecutionContext) => {
    const req = ctx.switchToHttp().getRequest<Request>();
    const f = { id: req.get('x-foydalanuvchi') ?? '0', ism: 'Aziz' };
    return maydon === undefined ? f : f[maydon];
  },
);

@Get('men')
men(
  @JoriyFoydalanuvchi() f: unknown,
  @JoriyFoydalanuvchi('id') id: string,
) {
  return { f, id };
}

GET /men → 200 {"f":{"id":"42","ism":"Aziz"},"id":"42"}

const Sahifa = createParamDecorator(
  (_: unknown, ctx: ExecutionContext) =>
    ctx.switchToHttp().getRequest<Request>().query['sahifa'],
);

@Get('sahifa')
sahifa(@Sahifa(ParseIntPipe) s: number) {
  return { s, turi: typeof s };
}

GET /sahifa?sahifa=3 → 200 {"s":3,"turi":"number"}
GET /sahifa?sahifa=uch → 400 {"message":"Validation failed (numeric string is expected)","error":"Bad Request","statusCode":400}

class Izoh { @IsString() @Length(1, 20) matn!: string; }
const IzohTanasi = createParamDecorator(
  (_: unknown, ctx: ExecutionContext) =>
    ctx.switchToHttp().getRequest<Request>().body as unknown,
);

@Post('izoh')
izoh(@IzohTanasi(new ValidationPipe({
  validateCustomDecorators: true,
})) i: Izoh) { return i; }

@Post('izoh-tekshiruvsiz')
izoh2(@IzohTanasi(new ValidationPipe()) i: Izoh) { return i; }

POST /izoh → 400 {"message":["matn must be longer than or equal to 1 characters"],"error":"Bad Request","statusCode":400}
POST /izoh-tekshiruvsiz → 201 {"matn":""}

const Rollar = Reflector.createDecorator<string[]>();

/** Bir nechta dekorator — bittada */
const AdminAmali = () => applyDecorators(
  Rollar(['admin']),
  UseGuards(RolGuard),
  HttpCode(202),
  Header('Cache-Control', 'no-store'),
);

@Post('admin') @AdminAmali() admin() { return 'qabul'; }

  [RolGuard] kerak=["admin"]
POST /admin → 202 cache-control: no-store qabul

const belgi = (kalit, qiymat) => (nishon) => {
  nishon.meta = { ...nishon.meta, [kalit]: qiymat };
};
const applyDecorators = (...dekoratorlar) => (nishon) => {
  for (const d of dekoratorlar) d(nishon);
};

const JsonTana = () => belgi("jsonTana", true);
const Interceptor = (nom) => belgi("interceptor", nom);
const VazifaYozuvi = () =>
  applyDecorators(JsonTana(), Interceptor("VazifaSarlavhalari"));

const yarat = { nom: "yarat" };
const ochir = { nom: "ochir" };
VazifaYozuvi()(yarat);
console.log(yarat.meta);
console.log(ochir.meta);

{ jsonTana: true, interceptor: 'VazifaSarlavhalari' }
undefined

// dekorator
@Post('admin') @AdminAmali() admin() { … }   // Rollar(['admin'])

// guard ichida — kalit o'rniga dekoratorning o'zi
const kerak = this.r.get(Rollar, k.getHandler());

  [RolGuard] kerak=["admin"]
POST /admin → 202 cache-control: no-store qabul
  [RolGuard] kerak=undefined
GET /oddiy → 200 oddiy

// dekoratorlar.ts — o'z parametr dekoratorlarimiz
// (createParamDecorator). Handler @Req() ni olib, ichida ajratish
// o'rniga — tayyor qiymat:
//   @IfMatchShart() shart: Shart | undefined — If-Match sarlavhasi
//                                              (yaroqsiz — 412)
//   @ToplamYoli("vazifalar") asos: string     — "/v1/vazifalar" yoki
//                                              eskirgan "/vazifalar"
//   @VazifaYozuvi()                           — dekoratorlar to'plami
import {
  applyDecorators, createParamDecorator, UseInterceptors,
} from "@nestjs/common";
import type { ExecutionContext } from "@nestjs/common";
import type { Request } from "express";
import { ifMatch } from "./shartli.ts";
import { asosYol } from "./yol.ts";
import { JsonTana } from "./json-tana.guard.ts";
import {
  VazifaSarlavhalariInterceptor,
} from "./vazifa-sarlavhalari.interceptor.ts";

export const IfMatchShart = createParamDecorator(
  (_: unknown, kontekst: ExecutionContext) =>
    ifMatch(kontekst.switchToHttp().getRequest<Request>()),
);

export const ToplamYoli = createParamDecorator(
  (toplam: string, kontekst: ExecutionContext) =>
    asosYol(kontekst.switchToHttp().getRequest<Request>(), toplam),
);

/** Bitta vazifani yozadigan endpoint (POST, PUT /:id, PATCH): tana
 * JSON (415) + javobga ETag/Last-Modified — bitta dekorator */
export const VazifaYozuvi = () =>
  applyDecorators(
    JsonTana(),
    UseInterceptors(VazifaSarlavhalariInterceptor),
  );

// vazifalar.controller.ts — /v1/vazifalar: HTTP ↔ xizmat (25-qism
// marshrut.ts dan). Kirish: Nest 12 `@Body/@Query/@Param({ schema })`
// — 25-qism Zod sxemalari, tekshiruv — global SxemaPipe; tana JSON —
// @JsonTana() + global guard (415); ETag/Last-Modified —
// interceptor; ikkalasi birga — @VazifaYozuvi(); Cache-Control —
// @Header; If-Match va to'plam yo'li — o'z parametr
// dekoratorlarimiz. @Res({ passthrough: true }) faqat Link,
// Location va 207 uchun
import {
  All, Body, Controller, Delete, Get, Header, HttpCode, Inject,
  Param, Patch, Post, Put, Query, Req, Res, UseInterceptors,
} from "@nestjs/common";
import type { Request, Response } from "express";
import { MetodYoqXatosi } from "../umumiy/xatolar.ts";
import type { MaydonXatosi } from "../umumiy/xatolar.ts";
import { JsonTana } from "../umumiy/json-tana.guard.ts";
import {
  IfMatchShart, ToplamYoli, VazifaYozuvi,
} from "../umumiy/dekoratorlar.ts";
import {
  VazifaSarlavhalariInterceptor,
} from "../umumiy/vazifa-sarlavhalari.interceptor.ts";
import { kursorYoz } from "../umumiy/kursor.ts";
import { ILOVA_SOZLAMALARI } from "../tokenlar.ts";
import type { IlovaSozlamalari } from "../tokenlar.ts";
import {
  BulkSxemasi, IdSxemasi, OzgarishSxemasi, RoyxatQuerySxemasi,
  ToliqVazifaSxemasi, ToplamSxemasi, YangiVazifaSxemasi,
} from "./sxema.ts";
import type { RoyxatQuery } from "./sxema.ts";
import type {
  ToliqVazifa, Vazifa, VazifaOzgarishi, YangiVazifa,
} from "./vazifa.ts";
import type { AlmashtirishVazifasi, Shart } from "./ombor.ts";
import { proyeksiya, royxatSorovi } from "./sorov.ts";
import { VazifalarService } from "./vazifalar.service.ts";

/** API javoblari: brauzer saqlashi mumkin, lekin har safar
 * tekshirsin (private — umumiy keshlar saqlamasin) */
const KESH = ["Cache-Control", "private, no-cache"] as const;

type Natija = {
  indeks: number;
  holat: number;
  vazifa?: Vazifa;
  xato?: MaydonXatosi;
};
type Id = { id: number };

// Versiya — ilova.ts dagi enableVersioning (URI): /v1/vazifalar
// va eskirgan /vazifalar
@Controller("vazifalar")
export class VazifalarController {
  constructor(
    private readonly xizmat: VazifalarService,
    @Inject(ILOVA_SOZLAMALARI)
    private readonly sozlamalar: IlovaSozlamalari,
  ) {}

  @Get()
  @Header(...KESH)
  async royxat(
    @Query({ schema: RoyxatQuerySxemasi }) query: RoyxatQuery,
    @ToplamYoli("vazifalar") asos: string,
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<object> {
    const { sorov, maydonlar, imzo } =
      royxatSorovi(query, this.sozlamalar.tz);
    const natija = await this.xizmat.royxat(sorov);
    const sahifa: Record<string, unknown> = { limit: sorov.limit };
    // Keyingi sahifa havolasi: query nusxasi, offset/cursor yangi
    const havola = (ozgartir: Record<string, string>): string => {
      const p = new URLSearchParams(
        req.originalUrl.split("?")[1] ?? "",
      );
      p.delete("offset");
      p.delete("cursor");
      for (const [k, v] of Object.entries(ozgartir)) p.set(k, v);
      return `${asos}?${p.toString()}`;
    };
    let keyingi: string | undefined;
    if (sorov.sahifa.tur === "offset") {
      sahifa.offset = sorov.sahifa.offset;
      if (natija.borKeyingi) {
        const offset = String(sorov.sahifa.offset + sorov.limit);
        keyingi = havola({ offset });
      }
    } else {
      const kursor =
        natija.keyingi && kursorYoz(natija.keyingi, imzo);
      sahifa.keyingi = kursor ?? null;
      if (kursor !== undefined) keyingi = havola({ cursor: kursor });
    }
    if (natija.jami !== undefined) sahifa.jami = natija.jami;
    // Link sarlavhasi (RFC 8288) — mijoz URL'ni o'zi yig'masin
    if (keyingi !== undefined) res.links({ next: keyingi });
    // ro'yxat ETag'i — Express'niki (tana xeshi, W/"…"): Nest javobni
    // res.json() bilan yuboradi → If-None-Match mos kelsa 304
    return {
      versiya: natija.versiya,
      vazifalar: natija.vazifalar.map(
        (v) => proyeksiya(v, maydonlar),
      ),
      sahifa,
    };
  }

  @Post()
  @VazifaYozuvi()
  async yarat(
    @Body({ schema: YangiVazifaSxemasi }) body: YangiVazifa,
    @ToplamYoli("vazifalar") asos: string,
    @Res({ passthrough: true }) res: Response,
  ): Promise<Vazifa> {
    const v = await this.xizmat.yarat(body);
    res.location(`${asos}/${String(v.id)}`);
    return v; // POST — sukut 201
  }

  /** PUT to'plamga — butun ro'yxatni almashtirish; atomik */
  @Put()
  @JsonTana()
  @Header(...KESH)
  async almashtirHammasi(
    @Body({ schema: ToplamSxemasi })
    body: { vazifalar: AlmashtirishVazifasi[] },
  ): Promise<object> {
    const { vazifalar, versiya } =
      await this.xizmat.almashtirHammasi(body.vazifalar);
    return { versiya, vazifalar };
  }

  // Express metod mos kelmasa 404 beradi — 405 + Allow ni o'zimiz
  // qo'yamiz (Allow ro'yxatini marshrutlar.test.ts tekshiradi)
  @All()
  toplamMetodYoq(@Req() req: Request): never {
    throw new MetodYoqXatosi(req.method, "GET, HEAD, POST, PUT");
  }

  /** Bulk yaratish — qisman muvaffaqiyat: 207 Multi-Status
   * (/:id dan OLDIN — aks holda "toplam" id deb olinadi) */
  @Post("toplam")
  @JsonTana()
  async toplam(
    @Body({ schema: BulkSxemasi }) body: { vazifalar: unknown[] },
    @Res({ passthrough: true }) res: Response,
  ): Promise<{ natijalar: Natija[] }> {
    // elementlar alohida tekshiriladi (qisman muvaffaqiyat) — pipe
    // emas, sxema bevosita
    const tekshirilgan = body.vazifalar.map(
      (el) => YangiVazifaSxemasi.safeParse(el),
    );
    const yaroqli = tekshirilgan.flatMap(
      (t) => (t.success ? [t.data] : []),
    );
    const yaratilgan = await this.xizmat.toplamYarat(yaroqli);
    let k = 0;
    const natijalar = tekshirilgan.map((t, indeks): Natija => {
      if (!t.success) {
        const xabar = t.error.issues.map((i) => i.message).join("; ");
        const joy = `body.vazifalar[${String(indeks)}]`;
        return { indeks, holat: 422, xato: { joy, xabar } };
      }
      const vazifa = yaratilgan[k++];
      return vazifa === undefined
        ? { indeks, holat: 500 }
        : { indeks, holat: 201, vazifa };
    });
    // dinamik status: passthrough bilan res.status() saqlanadi
    res.status(natijalar.every((n) => n.holat === 201) ? 201 : 207);
    return { natijalar };
  }

  @All("toplam")
  toplamPostYoq(@Req() req: Request): never {
    throw new MetodYoqXatosi(req.method, "POST");
  }

  @Get(":id")
  @Header(...KESH)
  @UseInterceptors(VazifaSarlavhalariInterceptor)
  ol(@Param({ schema: IdSxemasi }) { id }: Id): Promise<Vazifa> {
    return this.xizmat.ol(id);
  }

  /** PUT — to'liq almashtirish (idempotent: 2 marta = 1 marta) */
  @Put(":id")
  @VazifaYozuvi()
  almashtir(
    @Param({ schema: IdSxemasi }) { id }: Id,
    @Body({ schema: ToliqVazifaSxemasi }) body: ToliqVazifa,
    @IfMatchShart() shart: Shart | undefined,
  ): Promise<Vazifa> {
    return this.xizmat.almashtir(id, body, shart);
  }

  /** PATCH — qisman (JSON Merge Patch). If-Match: "3" — faqat
   * 3-versiya bo'lsa yoz */
  @Patch(":id")
  @VazifaYozuvi()
  yangila(
    @Param({ schema: IdSxemasi }) { id }: Id,
    @Body({ schema: OzgarishSxemasi }) body: VazifaOzgarishi,
    @IfMatchShart() shart: Shart | undefined,
  ): Promise<Vazifa> {
    return this.xizmat.yangila(id, body, shart);
  }

  @Delete(":id")
  @HttpCode(204)
  ochir(
    @Param({ schema: IdSxemasi }) { id }: Id,
    @IfMatchShart() shart: Shart | undefined,
  ): Promise<void> {
    return this.xizmat.ochir(id, shart);
  }

  @All(":id")
  birMetodYoq(@Req() req: Request): never {
    throw new MetodYoqXatosi(
      req.method, "GET, HEAD, PUT, PATCH, DELETE",
    );
  }
}

@Post()
@HttpCode(202)
boshla(
  @Body({ schema: EksportSxemasi }) body: EksportSorovi,
  @ToplamYoli("eksportlar") asos: string,
  @Res({ passthrough: true }) res: Response,
): Record<string, unknown> {
  const ish = this.eksport.boshla(body);
  res.location(`${asos}/${ish.id}`).set("Retry-After", "1");
  return this.eksport.korinish(ish, asos);
}

@Get(":id")
holat(
  @Param("id") id: string,
  @ToplamYoli("eksportlar") asos: string,
  @Res({ passthrough: true }) res: Response,
): Record<string, unknown> {
  const ish = this.eksport.topilsin(id);
  if (ish.holat === "kutilmoqda" || ish.holat === "bajarilmoqda") {
    res.set("Retry-After", "1");
  }
  res.set("Cache-Control", "no-store");
  return this.eksport.korinish(ish, asos);
}