8.21-bob: Hujjat generatsiya — PDF, Excel, CSV

  ┌────────┬──────────────────────────────────────────────────┐
  │ PDF    │ Chiroyli, qat'iy format, chop etiladigan.        │
  │        │ Chek, hisob-faktura, shartnoma, sertifikat.      │
  │        │ Tahrirlanmaydigan (yakuniy hujjat).              │
  ├────────┼──────────────────────────────────────────────────┤
  │ Excel  │ Tahrirlanadigan jadval, formula, stil, grafik.   │
  │ (.xlsx)│ Hisobot, ma'lumot tahlili (buxgalter ishlaydi).  │
  ├────────┼──────────────────────────────────────────────────┤
  │ CSV    │ Oddiy matn jadval (vergul bilan). Universal.     │
  │        │ Tizimlararo ko'chirish, ommaviy import/export.   │
  │        │ Yengil, tez (katta ma'lumot — streaming).        │
  └────────┴──────────────────────────────────────────────────┘

  PDFKit (dasturiy — kod bilan chizish):
   Yengil, tez, kam resurs; aniq nazorat (koordinata, chiziq)
   Murakkab dizayn qiyin (qo'lda joylashtirish)
   Oddiy chek, sertifikat, hisobot (dasturiy)

  Puppeteer (HTML  PDF — brauzer):
   HTML/CSS bilan dizayn (chiroyli, oson — veb kabi)
   Og'ir (headless Chrome — resurs, sekinroq)
   Murakkab dizayn (hisob-faktura, kataloq — HTML shablon)

import PDFDocument from "pdfkit";

function chekYarat(buyurtma: any): PDFDocument {
  const doc = new PDFDocument({ size: "A4", margin: 50 });
  doc.fontSize(20).text("CHEK", { align: "center" });   // sarlavha
  doc.moveDown();
  doc.fontSize(12).text(`Buyurtma: #${buyurtma.id}`);
  doc.text(`Sana: ${buyurtma.sana}`);
  doc.moveDown();
  buyurtma.items.forEach((i: any) => {                  // mahsulotlar
    doc.text(`${i.nom} — ${i.miqdor} x ${i.narx} = ${i.miqdor * i.narx} so'm`);
  });
  doc.moveDown().fontSize(14).text(`Jami: ${buyurtma.jami} so'm`, { align: "right" });
  doc.end();                                            // yakunlash
  return doc;                                           // stream (2.7)
}

// MUAMMO: PDFKit default shrifti (Helvetica — Afm) faqat lotin-1 (Latin-1).
//         O'zbek "o'g'", "ʻ" (tutuq), kirill — kvadrat (□□□) chiqadi.
// YECHIM: TrueType (.ttf) Unicode shrift EMBED qilish (PDF ichiga joylash).

import PDFDocument from "pdfkit";
import { join } from "path";

const doc = new PDFDocument();
// 1) Shriftni ro'yxatdan o'tkazish (nom bilan)
doc.registerFont("uz", join(process.cwd(), "assets/fonts/DejaVuSans.ttf"));
doc.registerFont("uz-bold", join(process.cwd(), "assets/fonts/DejaVuSans-Bold.ttf"));
// 2) Faol shriftni tanlash — endi barcha text() shu shrift bilan
doc.font("uz").fontSize(12).text("Bo'ronbekning to'lovi — 1 500 000 so'm");
doc.font("uz-bold").text("JAMI");   // qalin variant

import PdfPrinter from "pdfmake";

// Shriftlar (o'zbek — 2.3a): pdfmake ham TTF embed qiladi
const printer = new PdfPrinter({
  Roboto: {
    normal: "assets/fonts/Roboto-Regular.ttf",
    bold: "assets/fonts/Roboto-Medium.ttf",
    italics: "assets/fonts/Roboto-Italic.ttf",
    bolditalics: "assets/fonts/Roboto-MediumItalic.ttf",
  },
});

function chekDocDefinition(buyurtma: any) {
  return {                                              // DEKLARATIV — obyekt (chizmaymiz, tavsiflaymiz)
    content: [
      { text: "MANA DO'KON", style: "sarlavha" },
      { text: `Chek: #${buyurtma.id}`, margin: [0, 10, 0, 4] },
      {
        table: {                                        // JADVAL — deklarativ (koordinata emas)
          headerRows: 1,
          widths: ["*", "auto", "auto", "auto"],
          body: [
            ["Mahsulot", "Miqdor", "Narx", "Jami"],     // sarlavha qatori
            ...buyurtma.items.map((i: any) => [
              i.nom, i.miqdor, i.narx, i.miqdor * i.narx,
            ]),
          ],
        },
      },
      { text: `JAMI: ${buyurtma.jami} so'm`, style: "jami", alignment: "right" },
    ],
    styles: {
      sarlavha: { fontSize: 22, bold: true, alignment: "center" },
      jami: { fontSize: 14, bold: true, margin: [0, 10, 0, 0] },
    },
    defaultStyle: { font: "Roboto" },                   // o'zbek shrift
  };
}

async function pdfmakeYarat(buyurtma: any): Promise<Buffer> {
  const doc = printer.createPdfKitDocument(chekDocDefinition(buyurtma));
  const chunks: Buffer[] = [];
  doc.on("data", (c) => chunks.push(c));
  doc.end();
  return new Promise((resolve) => doc.on("end", () => resolve(Buffer.concat(chunks))));
}

import puppeteer from "puppeteer";

async function htmlPdfYarat(html: string): Promise<Buffer> {
  const browser = await puppeteer.launch({ headless: true, args: ["--no-sandbox"] });
  const page = await browser.newPage();
  await page.setContent(html, { waitUntil: "networkidle0" });   // HTML yuklash
  const pdf = await page.pdf({ format: "A4", printBackground: true });   // PDF
  await browser.close();                                // resurs bo'shatish (MUHIM)
  return pdf;
}
// HTML — Handlebars shablon 8.10-bob bilan: chiroyli hisob-faktura

import * as ExcelJS from "exceljs";

async function hisobotYarat(buyurtmalar: any[]): Promise<Buffer> {
  const wb = new ExcelJS.Workbook();
  const ws = wb.addWorksheet("Buyurtmalar");

  ws.columns = [                                       // ustunlar (sarlavha + kenglik)
    { header: "ID", key: "id", width: 10 },
    { header: "Mijoz", key: "mijoz", width: 25 },
    { header: "Summa", key: "summa", width: 15 },
    { header: "Sana", key: "sana", width: 20 },
  ];
  ws.getRow(1).font = { bold: true };                 // sarlavha qalin (stil)
  buyurtmalar.forEach((b) => ws.addRow(b));           // qatorlar

  ws.addRow({ mijoz: "JAMI:", summa: { formula: `SUM(C2:C${buyurtmalar.length + 1})` } });   // formula!
  return (await wb.xlsx.writeBuffer()) as Buffer;
}

// CSV YARATISH (oddiy — qo'lda yoki kutubxona)
function csvYarat(data: any[]): string {
  const sarlavha = Object.keys(data[0]).join(",");
  const qatorlar = data.map((row) =>
    Object.values(row).map((v) => `"${String(v).replace(/"/g, '""')}"`).join(","),   // escape!
  );
  return [sarlavha, ...qatorlar].join("\n");
}

// CSV PARSE (o'qish — import)
import { parse } from "csv-parse";
async function csvOqi(buffer: Buffer): Promise<any[]> {
  return new Promise((resolve, reject) => {
    parse(buffer, { columns: true, trim: true }, (err, records) => {
      if (err) reject(err); else resolve(records);    // har qator  obyekt
    });
  });
}

import * as fastcsv from "fast-csv";
import { Readable } from "stream";

// PARSE (import) — stream, katta faylga (xotira to'lmaydi — 2.7)
function fastCsvOqi(buffer: Buffer): Promise<any[]> {
  return new Promise((resolve, reject) => {
    const rows: any[] = [];
    Readable.from(buffer)
      .pipe(fastcsv.parse({ headers: true, trim: true }))   // birinchi qator sarlavha  obyekt
      .on("error", reject)
      .on("data", (row) => rows.push(row))                  // qator-qator (streamda)
      .on("end", () => resolve(rows));
  });
}

// FORMAT (eksport) — response'ga to'g'ridan stream (escape avtomatik)
@Get("export/fast.csv")
async fastExport(@Res() res: Response) {
  res.setHeader("Content-Type", "text/csv; charset=utf-8");
  res.setHeader("Content-Disposition", "attachment; filename=orders.csv");
  res.write("");                                       // UTF-8 BOM (Excel — 2.6)

  const csvStream = fastcsv.format({ headers: true });       // vergul/qo'shtirnoq — AVTOMATIK escape
  csvStream.pipe(res);                                       // to'g'ridan javobga (stream)
  const dbStream = this.orderRepo.createQueryBuilder("o").stream();   // DB stream (8.3)
  dbStream.on("data", (r) => csvStream.write({ ID: r.o_id, Mijoz: r.o_mijoz, Summa: r.o_summa }));
  dbStream.on("end", () => csvStream.end());
}

import Papa from "papaparse";

// Sodda parse (kichik/o'rta fayl — butun matnni bir marta) — frontend'da ham xuddi shu API
function papaOqi(matn: string): any[] {
  const natija = Papa.parse(matn, {
    header: true,          // birinchi qator — kalit
    skipEmptyLines: true,  // bo'sh qatorlarni tashla
    dynamicTyping: true,   // "12"  12 (raqamga avtomatik)
  });
  if (natija.errors.length) {
    throw new BadRequestException(`CSV xato: ${natija.errors[0].message} (qator ${natija.errors[0].row})`);
  }
  return natija.data;      // [{ nom: "...", narx: 5000 }, ...]
}

// MUAMMO: 100000 qator  xotirada to'liq  out of memory!
// YECHIM: streaming (qator-qator, xotirada to'planmaydi)

@Get("export")
async export(@Res() res: Response) {
  res.setHeader("Content-Type", "text/csv");
  res.setHeader("Content-Disposition", "attachment; filename=hisobot.csv");

  const stream = this.orderRepo.createQueryBuilder("o").stream();   // DB stream (8.3)
  res.write("id,mijoz,summa\n");                       // sarlavha
  stream.on("data", (row) => res.write(`${row.id},${row.mijoz},${row.summa}\n`));   // qator-qator
  stream.on("end", () => res.end());                   // tugadi
}

import { StreamableFile } from "@nestjs/common";
import { createReadStream } from "fs";

// USUL A: mavjud fayl (yoki buffer)  StreamableFile qaytarish (@Res() kerak emas!)
@Get("reports/orders.xlsx")
@Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
@Header("Content-Disposition", 'attachment; filename="buyurtmalar.xlsx"')
async hisobot(): Promise<StreamableFile> {
  const buffer = await this.excelHisobot(await this.ordersService.hammasi());
  return new StreamableFile(buffer);                   // NestJS o'zi pipe qiladi
}

// USUL B: disk/S3 dagi katta fayl  read stream (xotiraga yuklamasdan)
@Get("files/:id")
faylBer(@Param("id") id: string): StreamableFile {
  const fayl = createReadStream(join(process.cwd(), "storage", id));
  return new StreamableFile(fayl, {
    type: "application/pdf",
    disposition: 'attachment; filename="hujjat.pdf"',   // metadata konstruktorda ham beriladi
  });
}

@Post("import")
@UseInterceptors(FileInterceptor("file"))             // fayl yuklash (8.8)
async import(@UploadedFile() file: Express.Multer.File) {
  const records = await this.csvOqi(file.buffer);      // parse (2.6)
  const natija = { muvaffaqiyat: 0, xato: [] as any[] };

  for (const [i, row] of records.entries()) {
    const dto = plainToInstance(ImportRowDto, row);    // DTO (8.5)
    const xatolar = await validate(dto);               // validatsiya (8.5)
    if (xatolar.length) {
      natija.xato.push({ qator: i + 2, xatolar });     // qator raqami (xato hisoboti)
      continue;
    }
    await this.service.yarat(dto);
    natija.muvaffaqiyat++;
  }
  return natija;                                       // muvaffaqiyat + xatolar hisoboti
}

// Og'ir hisobot (10000+ qator)  fonda (so'rovni bloklamasin — 8.22)
@Post("reports/generate")
async hisobotSora(@Body() dto: ReportDto, @CurrentUser() user) {
  const job = await this.reportQueue.add("generate", { ...dto, userId: user.id });
  return { jobId: job.id, message: "Hisobot tayyorlanmoqda, tayyor bo'lganda xabar beramiz" };
}

@Processor("reports")
export class ReportProcessor extends WorkerHost {
  async process(job: Job) {
    const buffer = await this.excelHisobot(job.data);  // og'ir generatsiya (2.5)
    const url = await this.s3.yukla(buffer, `report-${job.id}.xlsx`);   // S3 (5.11)
    await this.notify.yubor(job.data.userId, `Hisobot tayyor: ${url}`);   // bildirishnoma (8.18)
  }
}

   To'g'ri format (PDF chek, Excel hisobot, CSV ko'chirish — 2.1)
   PDFKit (grafika) / pdfmake (jadval-deklarativ) / Puppeteer (chiroyli — 2.2, 2.3b, 2.4)
   Puppeteer browser pool + page.close() (xotira — 2.4)
   StreamableFile qaytar (@Res() dan afzal — interceptor mos — 2.7a)
   Streaming (katta ma'lumot — xotira — 2.7)
   fast-csv format() — escape avtomatik (qo'lda replace emas — 2.6a)
   Import validatsiya + xato hisoboti (qator raqami — 2.8)
   Og'ir generatsiya  navbat (fonda — 2.9, 8.22)
   O'zbek harflari shrift (Unicode — PDF — 2.3)
   CSV escape + UTF-8 BOM (Excel ochishi — 2.6)
   Excel formula/stil (buxgalter — 2.5); xavfsizlik (CSV injection — 2.10)

// PDFKit 2.3-bob: new PDFDocument()  registerFont/font  doc.text()  doc.end()  pipe(res)
// pdfmake (2.3b): printer.createPdfKitDocument(docDefinition)  content/table/styles
// Puppeteer 2.4-bob: page.setContent(html)  page.pdf()  browser.close()
// HandlebarsPDF (2a): Handlebars.compile(hbs)(data)  html  htmlPdf(html)
// Excel 2.5-bob: wb.addWorksheet()  ws.columns/addRow  wb.xlsx.writeBuffer()
// Excel stream (Misol 4): stream.xlsx.WorkbookWriter({ stream: res })  row.commit()
// CSV parse 2.6-bob: parse(buffer, { columns: true }) | fast-csv .parse({ headers: true }) | Papa.parse
// CSV format (2.6a): fastcsv.format({ headers: true }).pipe(res) — auto escape
// Stream 2.7-bob: repo.stream()  res.write(qator)  res.end()
// StreamableFile (2.7a): return new StreamableFile(buffer | readStream) — @Res() shart emas
// Import 2.8-bob: FileInterceptor  parse  validate  saqla

@Get("orders/:id/receipt")
async chek(@Param("id") id: string, @Res() res: Response) {
  const buyurtma = await this.ordersService.bitta(id);

  res.setHeader("Content-Type", "application/pdf");
  res.setHeader("Content-Disposition", `inline; filename=chek-${id}.pdf`);

  const doc = new PDFDocument({ size: "A4", margin: 50 });
  doc.pipe(res);                                       // to'g'ridan response'ga (stream — 2.7)

  doc.registerFont("uz", "fonts/DejaVuSans.ttf");      // Unicode shrift (o'zbek — 2.3)
  doc.font("uz");

  doc.fontSize(22).text("MANA DO'KON", { align: "center" });
  doc.fontSize(10).text("Chek / Hisob-faktura", { align: "center" });
  doc.moveDown();
  doc.fontSize(11).text(`Chek: #${buyurtma.id}`);
  doc.text(`Sana: ${buyurtma.createdAt.toLocaleDateString("uz")}`);
  doc.text(`Mijoz: ${buyurtma.mijoz.ism}`);
  doc.moveDown();

  // Jadval (mahsulotlar)
  buyurtma.items.forEach((i: any) => {
    doc.text(`${i.nom}`, 50, doc.y, { continued: true })
       .text(`${i.miqdor} x ${i.narx} = ${i.miqdor * i.narx} so'm`, { align: "right" });
  });
  doc.moveDown();
  doc.fontSize(14).text(`JAMI: ${buyurtma.jami} so'm`, { align: "right" });

  doc.end();                                           // stream tugaydi  response yopiladi
}

@Injectable()
export class PdfService {
  private browser: puppeteer.Browser;                 // qayta ishlatish (browser pool)

  async onModuleInit() {                               // (8.1 lifecycle)
    this.browser = await puppeteer.launch({ headless: true, args: ["--no-sandbox"] });
  }
  async onModuleDestroy() { await this.browser?.close(); }

  async htmlPdf(html: string): Promise<Buffer> {
    const page = await this.browser.newPage();         // pool'dan (har safar launch emas)
    try {
      await page.setContent(html, { waitUntil: "networkidle0" });
      return (await page.pdf({ format: "A4", printBackground: true,
        margin: { top: "20mm", bottom: "20mm", left: "15mm", right: "15mm" } })) as Buffer;
    } finally {
      await page.close();                              // sahifa yopiladi (browser qoladi)
    }
  }
}
// HTML — Handlebars shablon 8.10-bob bilan chiroyli hisob-faktura

// invoice.hbs (shablon fayli — assets/templates/invoice.hbs):
//
//   <!DOCTYPE html>
//   <html><head><meta charset="utf-8"><style>
//     body { font-family: 'DejaVu Sans', sans-serif; }   /* o'zbek shrift — CSS @font-face ham mumkin */
//     table { width: 100%; border-collapse: collapse; }
//     th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
//     th { background: #4f46e5; color: #fff; }
//     .jami { font-weight: bold; text-align: right; font-size: 18px; }
//   </style></head><body>
//     <h1>Hisob-faktura #{{id}}</h1>
//     <p>Mijoz: {{mijoz.ism}} — Sana: {{sana}}</p>
//     <table>
//       <tr><th>Mahsulot</th><th>Miqdor</th><th>Narx</th><th>Jami</th></tr>
//       {{#each items}}                                  {{! sikl — HTML/CSS bilim ishlaydi }}
//       <tr><td>{{nom}}</td><td>{{miqdor}}</td><td>{{narx}}</td><td>{{jami}}</td></tr>
//       {{/each}}
//     </table>
//     <p class="jami">JAMI: {{jami}} so'm</p>
//   </body></html>

import * as Handlebars from "handlebars";
import { readFileSync } from "fs";
import { join } from "path";

@Injectable()
export class InvoiceService {
  // Shablonni bir marta kompilyatsiya qilib keshlash (har so'rovda o'qimaslik)
  private shablon = Handlebars.compile(
    readFileSync(join(process.cwd(), "assets/templates/invoice.hbs"), "utf-8"),
  );

  constructor(private readonly pdfService: PdfService) {}   // Misol 2 — browser pool

  async fakturaPdf(buyurtma: any): Promise<Buffer> {
    const html = this.shablon({                          // ma'lumot  HTML (8.10 — render)
      id: buyurtma.id,
      mijoz: buyurtma.mijoz,
      sana: new Date(buyurtma.createdAt).toLocaleDateString("uz"),
      items: buyurtma.items.map((i: any) => ({ ...i, jami: i.miqdor * i.narx })),
      jami: buyurtma.jami,
    });
    return this.pdfService.htmlPdf(html);                // HTML  PDF (Puppeteer — Misol 2)
  }
}
// Handlebars 8.10-bob — chiroyli, tahrirlash oson (dizayner HTML/CSS ni o'zgartiradi, kod tegmaydi)

async excelHisobot(buyurtmalar: any[]): Promise<Buffer> {
  const wb = new ExcelJS.Workbook();
  wb.creator = "Mana Do'kon";
  const ws = wb.addWorksheet("Hisobot", {
    pageSetup: { paperSize: 9, orientation: "landscape" },
  });

  // Sarlavha qatori (stil bilan)
  ws.columns = [
    { header: "№", key: "n", width: 6 },
    { header: "Buyurtma ID", key: "id", width: 15 },
    { header: "Mijoz", key: "mijoz", width: 30 },
    { header: "Summa (so'm)", key: "summa", width: 18 },
    { header: "Holat", key: "holat", width: 15 },
    { header: "Sana", key: "sana", width: 20 },
  ];
  const sarlavha = ws.getRow(1);
  sarlavha.font = { bold: true, color: { argb: "FFFFFFFF" } };
  sarlavha.fill = { type: "pattern", pattern: "solid", fgColor: { argb: "FF4F46E5" } };   // ko'k fon
  sarlavha.alignment = { vertical: "middle", horizontal: "center" };

  // Ma'lumot qatorlari
  buyurtmalar.forEach((b, i) => {
    ws.addRow({ n: i + 1, id: b.id, mijoz: b.mijoz, summa: b.summa, holat: b.holat, sana: b.sana });
  });

  // Jami (formula — Excel ichida hisoblanadi)
  const jamiQator = ws.addRow({ mijoz: "JAMI:", summa: { formula: `SUM(D2:D${buyurtmalar.length + 1})` } });
  jamiQator.font = { bold: true };

  ws.getColumn("summa").numFmt = "#,##0";              // raqam formati (ming ajratish)
  return (await wb.xlsx.writeBuffer()) as Buffer;
}

// Controller — yuklab berish
@Get("reports/orders.xlsx")
async hisobot(@Res() res: Response) {
  const buffer = await this.excelHisobot(await this.ordersService.hammasi());
  res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
  res.setHeader("Content-Disposition", "attachment; filename=buyurtmalar.xlsx");
  res.send(buffer);
}

// 100000+ qator — streaming writer (xotira to'lmaydi)
@Get("reports/big.xlsx")
async kattaHisobot(@Res() res: Response) {
  res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
  res.setHeader("Content-Disposition", "attachment; filename=big.xlsx");

  const wb = new ExcelJS.stream.xlsx.WorkbookWriter({ stream: res });   // STREAM (2.7)
  const ws = wb.addWorksheet("Data");
  ws.columns = [{ header: "ID", key: "id" }, { header: "Summa", key: "summa" }];

  const dbStream = this.orderRepo.createQueryBuilder("o").stream();     // DB stream (8.3)
  dbStream.on("data", (row) => {
    ws.addRow({ id: row.o_id, summa: row.o_summa }).commit();           // qator yoz + commit (xotira bo'shaydi)
  });
  dbStream.on("end", async () => {
    await ws.commit();
    await wb.commit();                                 // yakunlash
  });
}

@Get("export/orders.csv")
async csvExport(@Res() res: Response) {
  res.setHeader("Content-Type", "text/csv; charset=utf-8");
  res.setHeader("Content-Disposition", "attachment; filename=orders.csv");
  res.write("");                                 // UTF-8 BOM (Excel o'zbekni to'g'ri ko'rsatadi — 2.6)
  res.write("ID,Mijoz,Summa,Sana\n");                  // sarlavha

  const stream = this.orderRepo.createQueryBuilder("o").stream();
  stream.on("data", (row) => {
    const escape = (v: any) => `"${String(v).replace(/"/g, '""')}"`;   // escape 2.6-bob
    res.write(`${escape(row.o_id)},${escape(row.o_mijoz)},${escape(row.o_summa)},${escape(row.o_sana)}\n`);
  });
  stream.on("end", () => res.end());
}

class ImportMahsulotDto {
  @IsString() @MinLength(2) nom: string;
  @Type(() => Number) @IsNumber() @Min(0) narx: number;
  @Type(() => Number) @IsInt() @Min(0) zaxira: number;
}

@Post("products/import")
@UseInterceptors(FileInterceptor("file"))             // (8.8)
async import(@UploadedFile(new ParseFilePipe({
  validators: [new FileTypeValidator({ fileType: "csv" })],   // CSV (8.8)
})) file: Express.Multer.File) {
  const records = await this.csvOqi(file.buffer);     // parse (2.6)
  const natija = { jami: records.length, muvaffaqiyat: 0, xatolar: [] as any[] };

  for (const [i, row] of records.entries()) {
    const dto = plainToInstance(ImportMahsulotDto, row);
    const errors = await validate(dto);
    if (errors.length) {
      natija.xatolar.push({                            // xato hisoboti (qator + sabab)
        qator: i + 2,                                  // +2 (sarlavha + 0-indeks)
        sabab: errors.map((e) => Object.values(e.constraints || {})).flat(),
      });
      continue;
    }
    await this.productsService.yarat(dto);
    natija.muvaffaqiyat++;
  }
  return natija;                                       // { jami: 100, muvaffaqiyat: 95, xatolar: [...] }
}

async excelOqi(buffer: Buffer): Promise<any[]> {
  const wb = new ExcelJS.Workbook();
  await wb.xlsx.load(buffer);
  const ws = wb.getWorksheet(1);
  const rows: any[] = [];

  ws.eachRow((row, rowNumber) => {
    if (rowNumber === 1) return;                       // sarlavha o'tkazib yuborish
    rows.push({
      nom: row.getCell(1).value,
      narx: row.getCell(2).value,
      zaxira: row.getCell(3).value,
    });
  });
  return rows;                                         // keyin validatsiya (Misol 6 kabi)
}

@Post("reports/request")
@UseGuards(JwtAuthGuard)
async hisobotSora(@Body() dto: ReportRequestDto, @CurrentUser() user) {
  const job = await this.reportQueue.add("excel", { filter: dto, userId: user.id });
  return { jobId: job.id, status: "tayyorlanmoqda" };
}

@Processor("reports")
export class ReportProcessor extends WorkerHost {
  constructor(
    private ordersService: OrdersService,
    private pdfService: PdfService,
    private s3: S3Service,
    private notify: NotificationsGateway,
  ) { super(); }

  async process(job: Job) {
    const data = await this.ordersService.hisobotData(job.data.filter);   // og'ir so'rov
    const buffer = await this.excelHisobot(data);                          // generatsiya (2.5)
    const url = await this.s3.yukla(buffer, `report-${job.id}.xlsx`);      // S3 (5.11)
    await this.notify.foydalanuvchigaYubor(job.data.userId, {              // bildirishnoma (8.18)
      matn: "Hisobotingiz tayyor", url,
    });
  }
}

async sertifikat(ism: string, kurs: string): Promise<Buffer> {
  const doc = new PDFDocument({ size: "A4", layout: "landscape", margin: 0 });
  const chunks: Buffer[] = [];
  doc.on("data", (c) => chunks.push(c));

  doc.rect(0, 0, doc.page.width, doc.page.height).fill("#f8f9fa");   // fon
  doc.rect(20, 20, doc.page.width - 40, doc.page.height - 40).lineWidth(3).stroke("#4f46e5");   // ramka

  doc.fillColor("#4f46e5").fontSize(40).text("SERTIFIKAT", 0, 100, { align: "center" });
  doc.fillColor("#333").fontSize(16).text("Ushbu sertifikat", { align: "center" });
  doc.fontSize(30).text(ism, { align: "center" });
  doc.fontSize(16).text(`"${kurs}" kursini muvaffaqiyatli tamomlagani uchun`, { align: "center" });

  doc.end();
  return new Promise((resolve) => doc.on("end", () => resolve(Buffer.concat(chunks))));
}

// Format bo'yicha hujjat (Strategy pattern — 9.2)
interface HujjatGenerator {
  yarat(data: any[]): Promise<Buffer>;
  contentType: string;
}
class PdfGenerator implements HujjatGenerator {
  contentType = "application/pdf";
  async yarat(data: any[]) { /* PDFKit — 2.3 */ return Buffer.from(""); }
}
class ExcelGenerator implements HujjatGenerator {
  contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
  async yarat(data: any[]) { /* ExcelJS — 2.5 */ return Buffer.from(""); }
}
class CsvGenerator implements HujjatGenerator {
  contentType = "text/csv";
  async yarat(data: any[]) { /* CSV — 2.6 */ return Buffer.from(""); }
}

@Injectable()
export class ExportService {
  private generators = new Map<string, HujjatGenerator>([
    ["pdf", new PdfGenerator()], ["xlsx", new ExcelGenerator()], ["csv", new CsvGenerator()],
  ]);
  async export(format: string, data: any[]) {
    const gen = this.generators.get(format);          // Strategy (9.2)
    if (!gen) throw new BadRequestException("Format qo'llab-quvvatlanmaydi");
    return { buffer: await gen.yarat(data), contentType: gen.contentType };
  }
}
// ?format=pdf|xlsx|csv  bir endpoint, ko'p format

 100000 qator  buffer  OOM (2.7)
 streaming (qator-qator)

 har generatsiyada launch, close yo'q (xotira sizishi — 2.4)
 browser pool + page.close()

 CSV  to'g'ridan DB (noto'g'ri ma'lumot — 2.8)
 har qator validatsiya + xato hisoboti

 default shrift (Unicode emas — 2.3)
 registerFont (DejaVu/Unicode)

 UTF-8 BOM yo'q (2.6)
 res.write("") (BOM)