8.24-bob: Rasm/media qayta ishlash — sharp

  MUAMMO (xom rasm shundayligicha):
   8MB, 4000×3000  server joyi to'ladi, sayt sekin (mobil — dahshat)
   Turli joyda turli o'lcham (ro'yxat — kichik, sahifa — katta)
   Eski format (JPEG — WebP'dan 30% katta)
   EXIF — foydalanuvchi joylashuvi (maxfiylik!)

  YECHIM (sharp bilan):
   Resize (kerakli o'lcham), optimize (siqish — 8MB  200KB)
   Format (WebP/AVIF — zamonaviy, kichik)
   Bir necha o'lcham (thumbnail/medium/large)
   EXIF tozalash (maxfiylik)

import * as sharp from "sharp";

// sharp — zanjir (fluent — 9.2 Builder): o'qi  o'zgartir  chiqar
const natija = await sharp(inputBuffer)               // kirish (buffer/fayl)
  .resize(800, 600)                                   // o'lcham (2.3)
  .webp({ quality: 80 })                              // format + sifat (2.4)
  .toBuffer();                                        // chiqish (buffer/fayl)

// Yoki faylga
await sharp("input.jpg").resize(800).toFile("output.webp");

// Resize rejimlari (fit — belgilangan o'lchamga qanday sig'dirish)
sharp(input).resize(300, 300, { fit: "cover" });      // to'ldirish (proporsiya saqlab, ortiqchani kesadi — avatar)
sharp(input).resize(300, 300, { fit: "contain" });    // ichiga (proporsiya saqlab, atrofga bo'sh joy — fon bilan)
sharp(input).resize(300, 300, { fit: "inside" });     // proporsiya saqlab, ichiga — hech biri oshmasin (default)
sharp(input).resize(300, 300, { fit: "outside" });    // proporsiya saqlab, hech biri kichik bo'lmasin (kamida qoplaydi)
sharp(input).resize(300, 300, { fit: "fill" });       //  aniq 300×300 — proporsiya buziladi (cho'ziladi)
sharp(input).resize(800, null);                        // faqat kenglik (balandlik proporsional — avtomatik)
sharp(input).resize(null, 600);                        // faqat balandlik (kenglik avtomatik)
sharp(input).resize(800, null, { withoutEnlargement: true });   // kichikni kattalashtirmaslik

// position — cover/contain'da qaysi qism qoladi / qayerga tekislanadi
sharp(input).resize(300, 300, { fit: "cover", position: "top" });        // yuqorini saqlab kesadi (portret — yuz)
sharp(input).resize(300, 300, { fit: "cover", position: "attention" });  //  diqqat markazi (yuz/kontrast) avtomatik
sharp(input).resize(300, 300, { fit: "cover", position: "entropy" });    // eng ko'p detalli qismni saqlaydi

// background — contain'dagi bo'sh joy yoki shaffof PNG'ni JPEG fonini to'ldirish
sharp(input).resize(300, 300, { fit: "contain", background: "#ffffff" });          // oq fon
sharp(input).resize(300, 300, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } });  // shaffof (PNG/WebP)

  FORMATLAR (zamonaviy  kichik):
  - JPEG: keng, lekin katta (eski)
  - WebP: 25-35% kichik (JPEG'dan) — zamonaviy, keng qo'llab-quvvatlanadi
  - AVIF: 50% kichik — eng yangi (ba'zi eski brauzer qo'llamaydi)
  - PNG: shaffoflik (lekin katta — faqat kerak bo'lganda)

  SIQISH (quality 0-100):
  .webp({ quality: 80 })   sifat/hajm balansi (80 — odatda yaxshi)

// Bir rasmdan — bir necha o'lcham (turli joyga)
const olchamlar = [
  { nom: "thumbnail", en: 150 },                      // ro'yxat, avatar
  { nom: "medium", en: 600 },                         // sahifa
  { nom: "large", en: 1200 },                         // to'liq ko'rish
];

async hammaOlchamYarat(input: Buffer, id: string) {
  const natijalar: Record<string, string> = {};
  for (const o of olchamlar) {
    const buffer = await sharp(input).resize(o.en, null, { withoutEnlargement: true })
      .webp({ quality: 80 }).toBuffer();
    natijalar[o.nom] = await this.s3.yukla(buffer, `${id}-${o.nom}.webp`);   // S3 (5.11)
  }
  return natijalar;                                   // { thumbnail: url, medium: url, large: url }
}

// Watermark — logotip/matn qo'shish (mualliflik, brending)
async watermark(input: Buffer): Promise<Buffer> {
  const logo = await sharp("logo.png").resize(150).png().toBuffer();
  return sharp(input)
    .composite([{                                     // ustiga qo'yish
      input: logo,
      gravity: "southeast",                           // o'ng past burchak
      blend: "over",
    }])
    .toBuffer();
}
// Matn watermark — SVG orqali (matnni rasmga aylantirib composite)

// EXIF — rasm metadata (kamera, SANA, GPS JOYLASHUV — maxfiylik!)
const metadata = await sharp(input).metadata();       // { width, height, format, exif }

//  EXIF tozalash (foydalanuvchi joylashuvi oshkor bo'lmasin — 14)
const tozalangan = await sharp(input)
  .rotate()                                           // EXIF orientation'ga qarab to'g'rilash
  .withMetadata({ exif: {} })                         // EXIF tozalash (yoki .toBuffer — default tozalaydi)
  .toBuffer();

// sharp — rasm haqiqiyligini ham tekshiradi (magic bytes — 8.8: 2.4)
async tekshirVaIshla(buffer: Buffer) {
  const metadata = await sharp(buffer).metadata();    // rasm emas  xato (haqiqiy tekshiruv)
  if (!["jpeg", "png", "webp"].includes(metadata.format)) {
    throw new BadRequestException("Faqat rasm");
  }
  if (metadata.width > 8000 || metadata.height > 8000) {   // juda katta (DoS)
    throw new BadRequestException("Rasm o'lchami juda katta");
  }
  // Qayta ishlash  optimallashgan, xavfsiz
  return sharp(buffer).resize(2000, null, { withoutEnlargement: true }).webp({ quality: 82 }).toBuffer();
}

// Og'ir qayta ishlash (ko'p o'lcham, video)  fonda (8.22)
@Post("upload")
@UseInterceptors(FileInterceptor("rasm"))
async yukla(@UploadedFile() file: Express.Multer.File) {
  // 1. Original tez saqlash (yoki vaqtinchalik)
  const url = await this.s3.yukla(file.buffer, `temp/${randomUUID()}`);
  // 2. Qayta ishlash navbatga (so'rovni bloklamaslik — 8.22)
  await this.imageQueue.add("process", { url, userId: file.userId });
  return { url, holat: "qayta ishlanmoqda" };          // darrov javob
}
// Worker: bir necha o'lcham, watermark, optimize (fonda — 8.22)

# sharp o'rnatish — libvips (C kutubxona) bilan birga keladi (prebuilt binary)
npm install sharp

#  platformaga mos binary avtomatik yuklanadi. Docker/CI'da boshqa platforma bo'lsa:
npm install --os=linux --cpu=x64 sharp    # (masalan Alpine Linux uchun --libc=musl)

// Versiya va libvips holatini tekshirish (diagnostika)
import * as sharp from "sharp";
console.log(sharp.versions);        // { vips: "8.15.1", sharp: "0.33.x" }
console.log(sharp.format);          // qo'llab-quvvatlanadigan format ro'yxati (jpeg, webp, avif...)

sharp(input).rotate(90);                                 // 90° soat yo'nalishida burish
sharp(input).rotate();                                   // EXIF orientation'ga qarab avto-to'g'rilash (2.7)
sharp(input).rotate(45, { background: "#ffffff" });      // ixtiyoriy burchak (bo'sh joy fon bilan)
sharp(input).flip();                                     // vertikal aylantirish (yuqoripast)
sharp(input).flop();                                     // gorizontal aylantirish (chapo'ng — ko'zgu)

// extract — aniq to'rtburchakni kesib olish (crop — piksel koordinatasi bilan)
sharp(input).extract({ left: 100, top: 50, width: 400, height: 300 });

// trim — bir xil rangdagi chekka (bo'sh ramka) ni avtomatik olib tashlash
sharp(input).trim();                                     // logotip atrofidagi ortiqcha bo'shliq

// toFormat — formatni dinamik tanlash (o'zgaruvchi bilan)
const fmt = "webp";
sharp(input).toFormat(fmt as keyof sharp.FormatEnum, { quality: 80 });

// JPEG — progressive (bosqichma-bosqich yuklanadi — sekin internetda UX yaxshi)
sharp(input).jpeg({ quality: 82, progressive: true, mozjpeg: true });   // mozjpeg — yaxshiroq siqish

// PNG — lossless (yo'qotishsiz), siqish darajasi
sharp(input).png({ compressionLevel: 9, palette: true });               // palette — kam rangli PNG kichrayadi

// WebP — lossless yoki lossy
sharp(input).webp({ quality: 80, lossless: false, effort: 4 });         // effort 0-6 (sekinroq = kichikroq)

// AVIF — eng zamonaviy, eng kichik
sharp(input).avif({ quality: 50, effort: 4 });

// GIF — asosan animatsiya uchun (statik rasmga WebP/PNG afzal)
sharp(input, { animated: true }).gif({ colours: 128, effort: 7 });   // rang palitrasi (kam rang = kichik)

sharp(input).blur(5);                                    // xiralashtirish (radius — placeholder, maxfiylik)
sharp(input).sharpen();                                  // o'tkirlash (resize'dan keyin aniqlikni tiklaydi)
sharp(input).grayscale();                                // oq-qora (kul rang)
sharp(input).tint({ r: 255, g: 240, b: 220 });           // rang tusi berish (issiq/sovuq)
sharp(input).gamma(2.2);                                 // gamma korreksiya (yorug'lik egri chizig'i)
sharp(input).negate();                                   // rang inversiyasi (negativ)
sharp(input).modulate({ brightness: 1.1, saturation: 1.2, hue: 15 });   // yorqinlik/to'yinganlik/tus
sharp(input).median(3);                                  // shovqin kamaytirish (median filtr)

const meta = await sharp(input).metadata();
// { width, height, format, space, channels, hasAlpha, orientation, exif, density, isProgressive }

const stats = await sharp(input).stats();
// { channels: [{ min, max, mean, ... }], isOpaque, entropy, dominant: { r, g, b } }
// dominant — asosiy rang (galereya foni, placeholder rangi uchun)

// toBuffer — natijani xotirada Buffer (S3'ga yuborish, DB, HTTP javob — 5.11)
const buffer = await sharp(input).resize(800).webp().toBuffer();

// toFile — to'g'ridan diskka (format kengaytmadan aniqlanadi)
const info = await sharp(input).resize(800).toFile("output.webp");   // { width, height, size, format }

// Stream pipeline: Multer stream  sharp transform  S3 (buffersiz, kam xotira)
import { PassThrough } from "stream";
const transformer = sharp().resize(1200).webp({ quality: 80 });      // Transform stream
const passthrough = new PassThrough();
transformer.pipe(passthrough);                                       // sharp  S3 stream
fileStream.pipe(transformer);                                        // Multer stream  sharp
await this.s3.upload({ Body: passthrough, Key: key }).promise();     // oqim orqali yuklash

// Image bomb himoyasi — kichik faylda ulkan piksel (dekompressiya bombasi — DoS)
sharp(input, { limitInputPixels: 268402689 });           // ~16384×16384 default; kamaytirish mumkin
sharp(input, { limitInputPixels: 100_000_000 });         // maks 100 megapiksel
sharp(input, { limitInputPixels: false });               //  o'chirmang (xavfli!)

// failOn — buzuq rasmda qattiq to'xtash (truncated fayl qabul qilmaslik)
sharp(input, { failOn: "error" });

// Global performance sozlamalar (server ishga tushishida bir marta)
sharp.concurrency(4);                                    // parallel thread soni (CPU yadrolari)
sharp.cache({ memory: 200, files: 20, items: 100 });     // libvips operatsiya keshi
sharp.cache(false);                                      // serverless (Lambda)'da keshni o'chirish

// Animatsiyali GIF/WebP — barcha kadrlarni saqlab qayta ishlash
const anim = await sharp(input, { animated: true })      //  animated: true — barcha kadr
  .resize(300)                                           // barcha kadrga qo'llaniladi
  .webp()                                                // animatsiyali WebP (GIF'dan kichik)
  .toBuffer();

// Cloudinary — tashqi rasm xizmati (URL orqali transform, sharp o'rniga/bilan)
// Yuklash: cloudinary.uploader.upload(buffer)  optimallash URL'da (w_300,f_auto,q_auto)
// sharp — o'z serveringizda nazorat; Cloudinary/imgproxy — CDN + on-the-fly transform

   Yuklangan rasmni QAYTA ISHLA (xom saqlama — 2.1)
   WebP/AVIF format + siqish (quality ~80 — 2.4)
   Bir necha o'lcham (responsive — thumbnail/medium/large — 2.5)
   EXIF tozalash (maxfiylik — GPS — 14, 2.7) + .rotate()
   sharp validatsiya (rasm haqiqiyligi, o'lcham — DoS — 2.8)
   Og'ir  fonda (navbat — 2.9, 8.22)
   Original saqlash (qayta ishlash kerak bo'lsa) yoki o'chirish
   S3/CDN 5.11-bob + lazy loading (frontend — 13)
   withoutEnlargement (kichikni kattalashtirmaslik — 2.3)
   limitInputPixels (image bomb himoyasi — DoS — 2.16)
   resize  sharpen (thumbnail aniqligi — 2.13)
   animated: true (GIF/animatsiyali WebP — 2.17)
   Serverless'da sharp.cache(false) (2.16)

// sharp zanjir (2.2)
sharp(input).resize(en, balandlik, { fit }).webp({ quality }).toBuffer()

// Resize 2.3-bob: fit: "cover"|"contain"|"inside"; withoutEnlargement
// Format 2.4-bob: .webp/.jpeg/.avif/.png({ quality })
// Composite 2.6-bob: .composite([{ input: logo, gravity, blend }])
// Metadata 2.7-bob: .metadata()  { width, height, format }
// EXIF 2.7-bob: .rotate().withMetadata({ exif: {} })
// Geometrik 2.11-bob: .rotate(gradus) .flip() .flop() .extract({left,top,width,height}) .trim()
// Format 2.12-bob: .toFormat(nom) .jpeg({progressive,mozjpeg}) .png({palette}) .webp({lossless,effort})
// Filtr 2.13-bob: .blur(r) .sharpen() .grayscale() .tint() .gamma() .negate() .modulate()
// Stats 2.14-bob: .stats()  { dominant, entropy, channels }
// Chiqish 2.15-bob: .toBuffer() / .toFile(yo'l) / sharp() Transform stream (pipe)
// Xavfsizlik 2.16-bob: sharp(in, { limitInputPixels, failOn }); sharp.concurrency()/cache()
// Animatsiya 2.17-bob: sharp(in, { animated: true })

@Injectable()
export class ImageService {
  constructor(private s3: S3Service) {}

  async optimallash(buffer: Buffer): Promise<Buffer> {
    return sharp(buffer)
      .rotate()                                       // EXIF orientation (2.7)
      .resize(2000, null, { withoutEnlargement: true, fit: "inside" })   // maks 2000px (2.3)
      .webp({ quality: 82 })                          // WebP siqish (2.4)
      .toBuffer();                                    // EXIF avtomatik tozalanadi (2.7)
  }
}

@Injectable()
export class ImageVariantService {
  private readonly OLCHAMLAR = [
    { nom: "thumb", en: 150 },
    { nom: "small", en: 400 },
    { nom: "medium", en: 800 },
    { nom: "large", en: 1600 },
  ];

  async variantlarYarat(buffer: Buffer, prefix: string): Promise<Record<string, string>> {
    const natijalar: Record<string, string> = {};

    // Parallel (Promise.all — tez)
    await Promise.all(this.OLCHAMLAR.map(async (o) => {
      const out = await sharp(buffer)
        .rotate()
        .resize(o.en, null, { withoutEnlargement: true, fit: "inside" })
        .webp({ quality: o.en <= 400 ? 75 : 82 })     // kichikga ko'proq siqish
        .toBuffer();
      natijalar[o.nom] = await this.s3.yukla(out, `${prefix}-${o.nom}.webp`);
    }));

    return natijalar;                                 // { thumb, small, medium, large } URL
  }
}

async avatar(buffer: Buffer, userId: string): Promise<string> {
  const out = await sharp(buffer)
    .rotate()
    .resize(256, 256, { fit: "cover", position: "centre" })   // kvadrat (cover — kesadi — 2.3)
    .webp({ quality: 85 })
    .toBuffer();
  return this.s3.yukla(out, `avatars/${userId}.webp`);
}
// Dumaloq avatar — frontend CSS (border-radius); yoki SVG mask (sharp)

async watermark(buffer: Buffer): Promise<Buffer> {
  const meta = await sharp(buffer).metadata();
  // Logo o'lchamini rasmga moslab (10%)
  const logoEn = Math.round((meta.width || 800) * 0.15);
  const logo = await sharp("assets/logo.png").resize(logoEn).png().toBuffer();

  return sharp(buffer)
    .composite([{ input: logo, gravity: "southeast", blend: "over" }])   // o'ng past (2.6)
    .webp({ quality: 82 })
    .toBuffer();
}

@Injectable()
export class ImageValidationPipe implements PipeTransform {
  async transform(file: Express.Multer.File) {
    if (!file) throw new BadRequestException("Rasm yo'q");
    try {
      const meta = await sharp(file.buffer).metadata();   // rasm emas  xato (8.8: 2.4)
      if (!["jpeg", "png", "webp", "gif"].includes(meta.format!)) {
        throw new BadRequestException("Faqat rasm fayllari");
      }
      if ((meta.width || 0) > 10000 || (meta.height || 0) > 10000) {
        throw new BadRequestException("Rasm o'lchami juda katta (DoS)");   // (2.8)
      }
      return file;
    } catch {
      throw new BadRequestException("Yaroqsiz rasm");
    }
  }
}

// Controller
@Post("upload")
@UseInterceptors(FileInterceptor("rasm"))
yukla(@UploadedFile(ImageValidationPipe) file: Express.Multer.File) {
  return this.imageService.qaytaIshla(file.buffer);
}

@Post("products/:id/images")
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles(Rol.ADMIN)                                     // (8.7)
@UseInterceptors(FilesInterceptor("rasmlar", 10))    // ko'p rasm (8.8)
async mahsulotRasmlari(
  @Param("id") productId: string,
  @UploadedFiles() files: Express.Multer.File[],
) {
  const natijalar = [];
  for (const file of files) {
    await sharp(file.buffer).metadata();              // validatsiya (2.8)
    const variantlar = await this.variantService.variantlarYarat(   // 4 o'lcham (Misol 2)
      file.buffer, `products/${productId}/${randomUUID()}`,
    );
    natijalar.push(variantlar);
  }
  await this.productsService.rasmlarQosh(productId, natijalar);   // DB'ga URL (5.11: 2.12)
  return natijalar;
}

@Post("upload")
@UseInterceptors(FileInterceptor("rasm"))
async yukla(@UploadedFile(ImageValidationPipe) file: Express.Multer.File, @CurrentUser() user) {
  // 1. Original vaqtinchalik saqlash (tez)
  const tempKey = `temp/${randomUUID()}`;
  await this.s3.yukla(file.buffer, tempKey);
  // 2. Qayta ishlash navbatga (8.22)
  const job = await this.imageQueue.add("process", { tempKey, userId: user.id });
  return { jobId: job.id, holat: "qayta ishlanmoqda" };
}

@Processor("image")
export class ImageProcessor extends WorkerHost {
  async process(job: Job) {
    const buffer = await this.s3.yuklab(job.data.tempKey);   // original
    const variantlar = await this.variantService.variantlarYarat(buffer, `final/${job.id}`);
    await this.s3.ochir(job.data.tempKey);                    // temp tozalash
    await this.notify.yubor(job.data.userId, "Rasm tayyor", variantlar);   // (8.23)
  }
}

// Accept header'ga qarab format (AVIF > WebP > JPEG)
@Get("images/:id")
async rasm(@Param("id") id: string, @Headers("accept") accept: string, @Res() res: Response) {
  const buffer = await this.s3.yuklab(`images/${id}`);
  let out: Buffer, contentType: string;

  if (accept?.includes("image/avif")) {
    out = await sharp(buffer).avif({ quality: 70 }).toBuffer();   // eng kichik (2.4)
    contentType = "image/avif";
  } else if (accept?.includes("image/webp")) {
    out = await sharp(buffer).webp({ quality: 80 }).toBuffer();
    contentType = "image/webp";
  } else {
    out = await sharp(buffer).jpeg({ quality: 82 }).toBuffer();   // eski brauzer
    contentType = "image/jpeg";
  }
  res.setHeader("Content-Type", contentType);
  res.setHeader("Cache-Control", "public, max-age=31536000");      // CDN kesh (1 yil)
  res.send(out);
}
//  Production'da CDN (Cloudflare/imgproxy) afzal — real-time emas

// Kichik blur placeholder (rasm yuklanguncha ko'rsatish — UX, 13)
async blurPlaceholder(buffer: Buffer): Promise<string> {
  const tiny = await sharp(buffer)
    .resize(20)                                       // juda kichik (20px)
    .blur()
    .webp({ quality: 30 })
    .toBuffer();
  return `data:image/webp;base64,${tiny.toString("base64")}`;   // inline base64 (DB'ga)
}
// Frontend: blur placeholder  asosiy rasm yuklangach almashtirish (silliq UX)

// Frontend crop editor koordinatalarini qo'llash (avatar tahrirlash)
interface CropDto {
  left: number; top: number; width: number; height: number;
}

async cropVaSaqla(buffer: Buffer, crop: CropDto, userId: string): Promise<string> {
  const meta = await sharp(buffer).metadata();
  // Chegara tekshiruvi (crop rasm ichida bo'lishi shart — aks holda sharp xato beradi)
  if (crop.left + crop.width > (meta.width || 0) || crop.top + crop.height > (meta.height || 0)) {
    throw new BadRequestException("Crop maydoni rasm chegarasidan tashqarida");
  }
  const out = await sharp(buffer)
    .rotate()                                            // EXIF 2.7-bob — koordinatadan oldin to'g'rilash
    .extract(crop)                                       // aniq to'rtburchak kesish (2.11)
    .resize(512, 512, { fit: "cover" })                 // standart o'lchamga (2.3)
    .sharpen()                                           // kesish/o'lchamdan keyin o'tkirlash (2.13)
    .webp({ quality: 85 })
    .toBuffer();
  return this.s3.yukla(out, `avatars/${userId}.webp`);
}

// Katta rasmni butun xotiraga yuklamasdan oqim orqali qayta ishlash
import { PassThrough } from "stream";
import { Upload } from "@aws-sdk/lib-storage";

@Injectable()
export class ImageStreamService {
  constructor(private s3: S3ClientProvider) {}

  async streamYukla(fileStream: NodeJS.ReadableStream, key: string): Promise<string> {
    // sharp() argumentsiz — Transform stream sifatida ishlaydi (2.15)
    const transformer = sharp({ limitInputPixels: 100_000_000 })   // image bomb himoyasi (2.16)
      .rotate()
      .resize(1600, null, { withoutEnlargement: true, fit: "inside" })
      .webp({ quality: 82 });

    const passthrough = new PassThrough();
    fileStream.pipe(transformer).pipe(passthrough);      // Multer  sharp  S3 oqimi

    const upload = new Upload({
      client: this.s3.client,
      params: { Bucket: "media", Key: `${key}.webp`, Body: passthrough, ContentType: "image/webp" },
    });
    await upload.done();
    return `https://cdn.example.com/${key}.webp`;
  }
}
//  Diskless streaming — RAM'da butun fayl yo'q; juda katta yuklash uchun

// Animatsiyali GIF ni kichikroq animatsiyali WebP ga aylantirish
async gifOptimallash(buffer: Buffer): Promise<Buffer> {
  const meta = await sharp(buffer, { animated: true }).metadata();
  // pages — kadr soni; pageHeight — bitta kadr balandligi
  if ((meta.pages || 1) > 1) {
    return sharp(buffer, { animated: true })             // barcha kadr (2.17)
      .resize(400, null, { withoutEnlargement: true })
      .webp({ quality: 75, effort: 4 })                  // animatsiyali WebP (GIF'dan ancha kichik)
      .toBuffer();
  }
  // Statik GIF  oddiy WebP
  return sharp(buffer).resize(400, null, { withoutEnlargement: true }).webp({ quality: 80 }).toBuffer();
}

  src/images/
  ├── image.service.ts           (optimallash — Misol 1)
  ├── image-variant.service.ts   (responsive — Misol 2)
  ├── image-stream.service.ts    (stream pipeline — Misol 11)
  ├── image-validation.pipe.ts   (validatsiya + limitInputPixels — Misol 5, 2.16)
  ├── image.processor.ts         (fonda — Misol 7)
  ├── images.controller.ts       (upload + crop + serve — Misol 6, 8, 10)
  └── images.module.ts

  Ilova ishga tushishida (main.ts):
  sharp.concurrency(4); sharp.cache({ memory: 200 });   // performance 2.16-bob

  Oqim:
  Upload (5.11/8.8)  validatsiya (sharp — 2.8)  variant yaratish (Misol 2)
   S3 5.11-bob  DB'ga URL'lar (5.11: 2.12)  frontend srcset (13)
  Og'ir  navbat (Misol 7); serve  CDN kesh (Misol 8)

 8MB original (sekin, joy — 2.1)
 resize + WebP (200KB)

 ro'yxatda 2000px rasm (behuda — 2.5)
 responsive (thumbnail/medium/large)

 GPS joylashuv oshkor (maxfiylik — 14, 2.7)
 EXIF tozalash + .rotate()

 MIME spoof (8.8: 2.4)
 sharp metadata (haqiqiy tekshiruv — 2.8)

 10 rasm × 4 o'lcham so'rovda (timeout — 2.9)
 navbat (fonda)