NestJS controller'lari: @Controller, @Get, @Param, @Body va @Res tuzog'i

r.route("/")
  .post(
    jsonKerak,
    tekshirib({ body: YangiVazifaSxemasi },
      async ({ body }, req, res) => {
        const v = await xizmat.yarat(body);
        vazifaSarlavhalari(res, v);
        res.status(201)
          .location(`${req.baseUrl}/${String(v.id)}`).json(v);
      }),
  )

@Controller('vazifalar')
class VazifalarController {
  @Get()
  royxat() { … }

  @Get(':id')
  ol(@Param('id') id: string) { … }

  @Post()
  yarat(@Body() body: unknown) { … }
}

LOG [RoutesResolver] VazifalarController {/vazifalar}: +13ms
LOG [RouterExplorer] Mapped {/vazifalar, GET} route +5ms
LOG [RouterExplorer] Mapped {/vazifalar/:id, GET} route +2ms
LOG [RouterExplorer] Mapped {/vazifalar/toplam, GET} route +1ms
LOG [RouterExplorer] Mapped {/vazifalar, POST} route +1ms
LOG [RouterExplorer] Mapped {/vazifalar/tekshir, POST} route +10ms
LOG [RoutesResolver] TajribaController {/tajriba}: +0ms
LOG [RouterExplorer] Mapped {/tajriba/sarlavha, GET} route +1ms

@Get()
royxat(
  @Query() q: Record<string, string>,
  @Query('limit') limit?: string,
) {
  return { q, limit, turi: typeof limit };
}

@Get(':id')
ol(
  @Param('id') id: string,
  @Param() hammasi: Record<string, string>,
) {
  return { id, turi: typeof id, hammasi };
}

@Post()
yarat(@Body() body: unknown, @Body('matn') matn?: string) {
  return { body, matn };
}

GET /vazifalar?limit=5&teg=uy → 200
  {"q":{"limit":"5","teg":"uy"},"limit":"5","turi":"string"}
GET /vazifalar/7 → 200
  {"id":"7","turi":"string","hammasi":{"id":"7"}}
POST /vazifalar → 201
  {"body":{"matn":"Non olish"},"matn":"Non olish"}

@Get('sarlavha')
@Header('Cache-Control', 'no-store')
sarlavha(@Headers('x-til') til?: string, @Ip() ip?: string) {
  return { til, ip };
}

GET /tajriba/sarlavha → 200 cache-control: no-store
  {"til":"uz","ip":"127.0.0.1"}

GET /tajriba/req?a=1 → 200
  {"metod":"GET","yol":"/tajriba/req","url":"/tajriba/req?a=1"}

GET /tajriba/async → 200
  ["osh","manti"]
GET /tajriba/bosh → 200 content-length: 0
  (bo'sh)

@Post('tekshir')
@HttpCode(200)
tekshir(@Body() body: unknown) {
  return { ok: true, body };
}

POST /vazifalar/tekshir → 200
  {"ok":true,"body":{"matn":"x"}}

@Get('eski')
@Redirect('https://example.com/yangi', 301)
eski() {}

@Get('dinamik')
@Redirect('https://example.com', 302)
dinamik(@Query('v') v?: string) {
  if (v === '2') return { url: 'https://example.com/v2' };
}

GET /tajriba/eski → 301 location: https://example.com/yangi
  Moved Permanently. Redirecting to https://example.com/yangi
GET /tajriba/dinamik?v=2 → 302 location: https://example.com/v2
  Found. Redirecting to https://example.com/v2

@Get('res')
res(@Res() res: Response) {
  res.status(200).json({ qolda: true });
}

@Get('res-unutildi')
resUnutildi(@Res() _res: Response) {
  return { kelmaydi: true };
}

GET /tajriba/res → 200
  {"qolda":true}
GET /tajriba/res-unutildi → TimeoutError

@Get('passthrough')
passthrough(@Res({ passthrough: true }) res: Response) {
  res.set('X-Versiya', '7');
  return { nest: 'yubordi' };
}

GET /tajriba/passthrough → 200 x-versiya: 7
  {"nest":"yubordi"}

GET /vazifalar/toplam → 200
  {"id":"toplam","turi":"string","hammasi":{"id":"toplam"}}

function marshrutlar(royxat) {
  const naqsh = (yol) => new RegExp(
    "^" + yol.replace(/:(\w+)/g, "(?<$1>[^/]+)") + "$",
  );
  return function top(metod, url) {
    for (const m of royxat) {
      if (m.metod !== metod) continue;
      const mos = naqsh(m.yol).exec(url);
      if (mos) return `${m.nomi} ${JSON.stringify(mos.groups ?? {})}`;
    }
    return "404";
  };
}

const notogri = marshrutlar([
  { metod: "GET", yol: "/vazifalar/:id", nomi: "ol" },
  { metod: "GET", yol: "/vazifalar/toplam", nomi: "toplam" },
]);
const togri = marshrutlar([
  { metod: "GET", yol: "/vazifalar/toplam", nomi: "toplam" },
  { metod: "GET", yol: "/vazifalar/:id", nomi: "ol" },
]);

console.log(notogri("GET", "/vazifalar/toplam"));
console.log(togri("GET", "/vazifalar/toplam"));
console.log(togri("GET", "/vazifalar/7"));
console.log(togri("DELETE", "/vazifalar/7"));

ol {"id":"toplam"}
toplam {}
ol {"id":"7"}
404

DELETE /vazifalar/7 → 404
  {"message":"Cannot DELETE /vazifalar/7","error":"Not Found","statusCode":404}

function asosYol(req, toplam) {
  const yol = req.path;
  const i = yol.indexOf(`/${toplam}`);
  return i === -1
    ? `/${toplam}`
    : yol.slice(0, i + toplam.length + 1);
}

console.log(asosYol({ path: "/v1/vazifalar/5" }, "vazifalar"));
console.log(asosYol({ path: "/vazifalar/5" }, "vazifalar"));
console.log(asosYol({ path: "/v1/vazifalar" }, "vazifalar"));
console.log(asosYol({ path: "/salom" }, "vazifalar"));

/v1/vazifalar
/vazifalar
/v1/vazifalar
/vazifalar

constructor(
  private readonly xizmat: VazifalarService,
  @Inject(ILOVA_SOZLAMALARI)
  private readonly sozlamalar: IlovaSozlamalari,
) {}

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

$ curl -X POST -H 'Content-Type: application/json' -d '{"matn":"Non olish #bozor"}' /v1/vazifalar
HTTP/1.1 201 Created
Location: /v1/vazifalar/1
{"id":1,"matn":"Non olish #bozor","bajarildi":false,"teglar":["bozor"],…,"versiya":1}

$ curl -X POST … -d '{"vazifalar":[{"matn":"Choy damlash"},{"matn":""}]}' /v1/vazifalar/toplam
HTTP/1.1 207 Multi-Status
{"natijalar":[{"indeks":0,"holat":201,"vazifa":{"id":2,…}},{"indeks":1,"holat":422,"xato":{"joy":"body.vazifalar[1]","xabar":"matn 1–100 belgi bo'lishi kerak"}}]}

$ curl -X DELETE /v1/vazifalar
HTTP/1.1 405 Method Not Allowed
Allow: GET, HEAD, POST, PUT
{"type":"about:blank","title":"Method Not Allowed","status":405,"detail":"DELETE bu manzilda yo'q","instance":"/v1/vazifalar",…}

$ curl /v1/vazifalar/abc
HTTP/1.1 400 Bad Request
{"type":"https://vazifalar-api.example/xatolar/parametr","title":"Parametr noto'g'ri","status":400,"detail":"id — musbat butun son",…}

$ curl -X POST -H 'Content-Type: text/plain' -d 'salom' /v1/vazifalar
HTTP/1.1 415 Unsupported Media Type
{"type":"about:blank","title":"Unsupported Media Type","status":415,"detail":"Content-Type: application/json bo'lishi kerak",…}

$ curl /vazifalar/1
HTTP/1.1 200 OK
Deprecation: @1792800000
Sunset: Sun, 24 Jan 2027 00:00:00 GMT
Link: </v1/vazifalar/1>; rel="successor-version"

// tokenlar.ts — DI tokenlari: interfeys (VazifaOmbori) va oddiy
// qiymatlar (log, sozlamalar) uchun. TS interfeysi ish vaqtida YO'Q —
// Nest uni constructor turidan taniy olmaydi, shuning uchun
// Symbol token + @Inject(TOKEN)
export const VAZIFA_OMBORI = Symbol("VAZIFA_OMBORI");
export const IDEMPOTENTLIK_OMBORI = Symbol("IDEMPOTENTLIK_OMBORI");
export const LOG = Symbol("LOG");
export const XABARCHI = Symbol("XABARCHI");
export const ILOVA_SOZLAMALARI = Symbol("ILOVA_SOZLAMALARI");

/** Controller'larga kerakli kichik sozlamalar (to'liq Config —
 * keyinroq ConfigModule bilan) */
export type IlovaSozlamalari = { tz: string };

// yol.ts — resurs to'plamining yo'li (Location, Link uchun).
// Express'da req.baseUrl ("/v1/vazifalar") router ulangan joyni
// berardi; Nest marshrutlarni ilovaning o'ziga ro'yxatdan o'tkazadi —
// baseUrl bo'sh. Yo'lni joriy so'rovdan olamiz: versiyali
// (/v1/vazifalar) va eskirgan (/vazifalar) yo'llar ikkalasi to'g'ri
import type { Request } from "express";

/** "/v1/vazifalar/5/x" va "vazifalar" → "/v1/vazifalar" */
export function asosYol(req: Request, toplam: string): string {
  const yol = req.path;
  const i = yol.indexOf(`/${toplam}`);
  return i === -1
    ? `/${toplam}`
    : yol.slice(0, i + toplam.length + 1);
}

import type { Request, RequestHandler } from "express";

/** Nest controller'lari uchun: handler boshida chaqiriladi */
export function jsonTanaKerak(req: Request): void {
  const tur = req.is(JSON_TURLARI);
  if (tur === false || tur === null) {
    throw new IlovaXatosi(
      415, "Content-Type: application/json bo'lishi kerak",
    );
  }
}

// vazifalar.controller.ts — /v1/vazifalar: HTTP ↔ xizmat (25-qism
// marshrut.ts dan). Hozircha kirish eski Zod `tekshir()` bilan
// handler ichida tekshiriladi (tartib Express'dagidek: 415 →
// params → query → body); keyinroq DTO va pipe'larga o'tadi.
// @Res({ passthrough: true }) — sarlavha qo'yish uchun Express
// javobi, lekin javob tanasini Nest o'zi yuboradi (return qiymati)
import {
  All, Controller, Delete, Get, HttpCode, Inject, Patch, Post, Put,
  Req, Res,
} from "@nestjs/common";
import type { Request, Response } from "express";
import { MetodYoqXatosi } from "../umumiy/xatolar.ts";
import type { MaydonXatosi } from "../umumiy/xatolar.ts";
import { jsonTanaKerak } from "../umumiy/json-kerak.ts";
import { kursorYoz } from "../umumiy/kursor.ts";
import {
  ifMatch, keshYoq, vazifaSarlavhalari,
} from "../umumiy/shartli.ts";
import { tekshir } from "../umumiy/tekshir.ts";
import { asosYol } from "../umumiy/yol.ts";
import {
  BulkSxemasi, IdSxemasi, OzgarishSxemasi, RoyxatQuerySxemasi,
  ToliqVazifaSxemasi, ToplamSxemasi, YangiVazifaSxemasi,
} from "./sxema.ts";
import type { Vazifa } from "./vazifa.ts";
import { proyeksiya, royxatSorovi } from "./sorov.ts";
import { VazifalarService } from "./vazifalar.service.ts";
import { ILOVA_SOZLAMALARI } from "../tokenlar.ts";
import type { IlovaSozlamalari } from "../tokenlar.ts";

/** Keyingi sahifa havolasi: query nusxasi, offset/cursor yangi */
function keyingiHavola(
  req: Request,
  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 `${asosYol(req, "vazifalar")}?${p.toString()}`;
}

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

// 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()
  async royxat(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<object> {
    const query = tekshir(RoyxatQuerySxemasi, req.query, "query");
    const { sorov, maydonlar, imzo } =
      royxatSorovi(query, this.sozlamalar.tz);
    const natija = await this.xizmat.royxat(sorov);
    const sahifa: Record<string, unknown> = { limit: sorov.limit };
    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 = keyingiHavola(req, { offset });
      }
    } else {
      const kursor =
        natija.keyingi && kursorYoz(natija.keyingi, imzo);
      sahifa.keyingi = kursor ?? null;
      if (kursor !== undefined) {
        keyingi = keyingiHavola(req, { 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
    keshYoq(res);
    return {
      versiya: natija.versiya,
      vazifalar: natija.vazifalar.map(
        (v) => proyeksiya(v, maydonlar),
      ),
      sahifa,
    };
  }

  @Post()
  async yarat(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<Vazifa> {
    jsonTanaKerak(req);
    const body = tekshir(YangiVazifaSxemasi, req.body, "body");
    const v = await this.xizmat.yarat(body);
    vazifaSarlavhalari(res, v);
    res.location(`${asosYol(req, "vazifalar")}/${String(v.id)}`);
    return v; // POST — sukut 201
  }

  /** PUT to'plamga — butun ro'yxatni almashtirish; atomik */
  @Put()
  async almashtirHammasi(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<object> {
    jsonTanaKerak(req);
    const body = tekshir(ToplamSxemasi, req.body, "body");
    const { vazifalar, versiya } =
      await this.xizmat.almashtirHammasi(body.vazifalar);
    keshYoq(res);
    return { versiya, vazifalar };
  }

  // Express metod mos kelmasa 404 beradi — 405 + Allow ni o'zimiz
  // qo'yamiz. @All() — shu yo'ldagi qolgan hamma metod; marshrutlar
  // e'lon tartibida ro'yxatdan o'tadi — aniq metodlar oldin
  @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")
  async toplam(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<{ natijalar: Natija[] }> {
    jsonTanaKerak(req);
    const body = tekshir(BulkSxemasi, req.body, "body");
    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 };
    });
    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")
  async ol(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<Vazifa> {
    const params = tekshir(IdSxemasi, req.params, "params");
    const v = await this.xizmat.ol(params.id);
    vazifaSarlavhalari(res, v);
    keshYoq(res);
    return v;
  }

  /** PUT — to'liq almashtirish (idempotent: 2 marta = 1 marta) */
  @Put(":id")
  async almashtir(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<Vazifa> {
    jsonTanaKerak(req);
    const params = tekshir(IdSxemasi, req.params, "params");
    const body = tekshir(ToliqVazifaSxemasi, req.body, "body");
    const v = await this.xizmat.almashtir(
      params.id, body, ifMatch(req),
    );
    vazifaSarlavhalari(res, v);
    return v;
  }

  /** PATCH — qisman (JSON Merge Patch). If-Match: "3" — faqat
   * 3-versiya bo'lsa yoz */
  @Patch(":id")
  async yangila(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): Promise<Vazifa> {
    jsonTanaKerak(req);
    const params = tekshir(IdSxemasi, req.params, "params");
    const body = tekshir(OzgarishSxemasi, req.body, "body");
    const v = await this.xizmat.yangila(
      params.id, body, ifMatch(req),
    );
    vazifaSarlavhalari(res, v);
    return v;
  }

  @Delete(":id")
  @HttpCode(204)
  async ochir(@Req() req: Request): Promise<void> {
    const params = tekshir(IdSxemasi, req.params, "params");
    await this.xizmat.ochir(params.id, ifMatch(req));
  }

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

// teglar.controller.ts — /v1/teglar: teglar va nechta vazifada
import { All, Controller, Get, Req, Res } from "@nestjs/common";
import type { Request, Response } from "express";
import { MetodYoqXatosi } from "../umumiy/xatolar.ts";
import { keshYoq } from "../umumiy/shartli.ts";
import type { TegSoni } from "./ombor.ts";
import { VazifalarService } from "./vazifalar.service.ts";

@Controller("teglar")
export class TeglarController {
  constructor(private readonly xizmat: VazifalarService) {}

  @Get()
  async teglar(
    @Res({ passthrough: true }) res: Response,
  ): Promise<{ teglar: TegSoni[] }> {
    keshYoq(res);
    return { teglar: await this.xizmat.teglar() };
  }

  @All()
  metodYoq(@Req() req: Request): never {
    throw new MetodYoqXatosi(req.method, "GET, HEAD");
  }
}

// eksport.controller.ts — POST → 202 Accepted + Location (holat
// resursi), mijoz so'rab turadi (polling), tayyor bo'lsa — fayl
import {
  Controller, Get, HttpCode, Post, Req, Res,
} from "@nestjs/common";
import type { Request, Response } from "express";
import { IlovaXatosi } from "../umumiy/xatolar.ts";
import { tekshir } from "../umumiy/tekshir.ts";
import { asosYol } from "../umumiy/yol.ts";
import { EksportSxemasi } from "../vazifalar/sxema.ts";
import { EksportService } from "./eksport.service.ts";

@Controller("eksportlar")
export class EksportController {
  constructor(private readonly eksport: EksportService) {}

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

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

  @Get(":id/fayl")
  fayl(
    @Req() req: Request,
    @Res({ passthrough: true }) res: Response,
  ): string {
    const ish = this.eksport.topilsin(String(req.params["id"]));
    if (ish.natija === undefined) {
      throw new IlovaXatosi(409, "Eksport hali tayyor emas", {
        kod: "eksport-tayyor-emas",
        sarlavha: "Eksport tayyor emas",
        httpSarlavhalar: { "Retry-After": "1" },
      });
    }
    const kengaytma = ish.sorov.format;
    const sana = ish.yaratildi.slice(0, 10);
    res.attachment(`vazifalar-${sana}.${kengaytma}`).type(
      kengaytma === "json"
        ? "application/json; charset=utf-8"
        : "text/csv; charset=utf-8",
    );
    // satr — Nest res.send() bilan yuboradi, Content-Type o'zgarmaydi
    return ish.natija;
  }
}

// vazifalar.module.ts — vazifalar xususiyat moduli:
// controller'lar + xizmat
import { Module } from "@nestjs/common";
import { VazifalarController } from "./vazifalar.controller.ts";
import { TeglarController } from "./teglar.controller.ts";

@Module({
  controllers: [VazifalarController, TeglarController],
  // providers va exports — keyingi darsda
})
export class VazifalarModule {}

src/eksport/eksport.controller.ts(11,32): error TS2307: Cannot find module './eksport.service.ts' or its corresponding type declarations.
src/vazifalar/teglar.controller.ts(7,34): error TS2307: Cannot find module './vazifalar.service.ts' or its corresponding type declarations.
src/vazifalar/vazifalar.controller.ts(27,34): error TS2307: Cannot find module './vazifalar.service.ts' or its corresponding type declarations.
src/vazifalar/vazifalar.controller.ts(94,10): error TS7006: Parameter 'v' implicitly has an 'any' type.