5.21-bob: Caching — Redis (chuqur)

  Redis = ulkan Map (2.9-JS), lekin alohida server (jarayon), tarmoq orqali ulaniladi
  kalit  qiymat:  "user:7"  "{...}"  "otp:998..."  "384726"

  Xotirada (RAM)  juda tez (mikrosekund)
  Disk DB (6)  sekinroq (millisekund) — lekin ko'p, ishonchli

  Caching        — DB natijasini keshlash (eng asosiy — 2.5)
  Session store  — sessiyalar 5.15-bob
  Vaqtinchalik   — OTP 5.18-bob, tasdiqlash kodlari (TTL bilan — 2.7)
  Rate limiting  — so'rov hisoblagich 5.20-bob
  Navbat (queue) — fon vazifalar (BullMQ — 5.22)
  Pub/Sub        — real-time xabar (Socket.io adapter — 5.13, 2.13)
  Leaderboard    — reyting (sorted set — 2.10)
  Hisoblagich    — ko'rishlar, like (INCR — atomik — 2.11)

npm install ioredis         # (5.2)

import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL);   // redis://localhost:6379 (5.8)

await redis.set("kalit", "qiymat");                // yozish
const q = await redis.get("kalit");                // o'qish

await redis.set("kalit", "qiymat");                // yozish
await redis.set("kalit", "qiymat", "EX", 60);      // 60 sekund TTL bilan (2.7)
await redis.get("kalit");                           // o'qish ("qiymat" yoki null)
await redis.del("kalit");                           // o'chirish
await redis.exists("kalit");                        // bormi (1/0)
await redis.incr("hisob");                          // +1 (atomik — 2.11)
await redis.expire("kalit", 120);                   // TTL o'rnatish
await redis.ttl("kalit");                           // qancha qoldi (sekund)

  So'rov  Redis'da bormi?
            ├─ HA (cache hit)  Redis'dan qaytar (tez!) 
            └─ YO'Q (cache miss)  DB'dan ol (6)  Redis'ga sakla (TTL)  qaytar

  Keyingi so'rovlar  Redis'dan (DB'ga bormaydi — tez, DB yuki kam)

async function mahsulotOl(id) {
  const kesh = await redis.get(`product:${id}`);   // 1. Redis'da bormi?
  if (kesh) return JSON.parse(kesh);                // cache hit (tez!)

  const m = await Product.findById(id);             // 2. cache miss  DB (6)
  await redis.set(`product:${id}`, JSON.stringify(m), "EX", 3600);  // 3. Redis'ga (1 soat)
  return m;
}

  Cache-aside (lazy)   — ilova o'zi: miss bo'lsa DB'dan olib, keshga yozadi (2.5 — yuqorida)
  Read-through         — kesh qatlami o'zi DB'dan oladi (ilova faqat keshga murojaat) — kutubxona/proxy
  Write-through        — yozishda: DB'ga VA keshga birga yoziladi (kesh doim yangi, lekin yozish sekinroq)
  Write-behind         — yozishda: avval keshga, DB'ga keyinroq (fon — tez, lekin yo'qolish xavfi)

  Strategiyalar:
  1. TTL — kesh muddat bilan (eski avtomatik o'chadi — 2.7) — sodda, ko'p ishlatiladi
  2. Write-through/invalidate — ma'lumot o'zgarsa, keshni darrov o'chir/yangila
  3. Ikkalasi — TTL (xavfsizlik to'ri) + o'zgarishda o'chirish

// Ma'lumot o'zgarganda keshni o'chirish (2.6)
async function mahsulotYangila(id, data) {
  await Product.findByIdAndUpdate(id, data);        // DB (6)
  await redis.del(`product:${id}`);                  // keshni o'chir (eski qolmasin)
  // keyingi so'rov DB'dan yangi oladi va qayta keshlaydi (2.5)
}

await redis.set("otp:998...", kod, "EX", 120);     // 120 sekund (5.18)
await redis.set("cache", data, "EX", 3600);        // 1 soat
await redis.expire("kalit", 60);                    // mavjud kalitga TTL
await redis.ttl("kalit");                           // qoldi (-1: TTL yo'q; -2: yo'q)

  TTL tugadi  1000 so'rov bir vaqtda  1000 ta DB so'rovi (gala!)  DB sekinlashadi/yiqiladi

  Yechimlar:
  - Lock (mutex)  — birinchi miss qoluvchi DB'dan oladi (SETNX), qolganlari biroz kutadi/eski beradi
  - Erta yangilash — TTL tugashidan oldin fonda qayta keshlash (stale-while-revalidate)
  - TTL'ga "jitter" — bir xil TTL bermay, ozgina tasodifiy farq (kalitlar bir paytda tugamaydi)

  noeviction       — o'chirmaydi, yangi yozishni rad etadi (xato) — default
  allkeys-lru      — eng kam ishlatilgan kalitni o'chiradi (kesh uchun ideal — eng mashhuri)
  allkeys-lfu      — eng kam CHASTOTADA ishlatilganni (LFU — ba'zan yaxshiroq)
  volatile-ttl     — TTL'i bor kalitlar ichidan muddati yaqinini o'chiradi

// String — oddiy qiymat (matn, son, JSON)
await redis.set("ism", "Ali");
await redis.set("hisob", "0");
await redis.incr("hisob");                          // "1" (atomik son — 2.11)
await redis.incrby("hisob", 5);                     // "6"
await redis.mset("a", "1", "b", "2");              // ko'p yozish
await redis.mget("a", "b");                         // ["1", "2"]

// Hash — obyekt (user:7  { ism, email, yosh })
await redis.hset("user:7", { ism: "Ali", email: "ali@a.uz", yosh: "25" });
await redis.hget("user:7", "ism");                  // "Ali"
await redis.hgetall("user:7");                       // { ism, email, yosh }
await redis.hincrby("user:7", "yosh", 1);           // yosh + 1

// LIST — tartibli ro'yxat (navbat, oxirgi N element)
await redis.lpush("xabarlar", "a");                 // boshiga qo'sh
await redis.rpush("xabarlar", "b");                 // oxiriga qo'sh
await redis.lrange("xabarlar", 0, 9);              // oxirgi 10 ta

// SET — takrorlanmas to'plam (2.9-JS: Set)
await redis.sadd("teglar", "js", "node", "js");    // {js, node} (takror yo'q)
await redis.smembers("teglar");                      // ["js", "node"]
await redis.sismember("teglar", "js");             // bor (1)

// SORTED SET — ball bilan tartiblangan (leaderboard, reyting — 2.2)
await redis.zadd("reyting", 100, "Ali", 85, "Vali");
await redis.zrevrange("reyting", 0, 9, "WITHSCORES");  // top 10 (yuqori ball)

// Atomik hisoblagich (race condition yo'q — 5.1: event loop)
await redis.incr(`views:post:${id}`);              // ko'rishlar (bir vaqtda ko'p so'rov — to'g'ri)

//  Bu race condition'li bo'lardi (oddiy DB'da):
//    val = get(); val = val + 1; set(val);   ikki so'rov orasida yo'qolishi mumkin
//  INCR — atomik (Redis bir vaqtda bittasini bajaradi)

  session:abc123  { userId: 7, ... }  (TTL: 24 soat)

   ko'p server bir Redis'ga ulanadi  sessiya barcha serverda bir xil (5.15: 2.9)
   TTL bilan eski sessiyalar avtomatik o'chadi

// Nashr qiluvchi
await redis.publish("yangiliklar", JSON.stringify({ matn: "Salom" }));

// Obunachi (alohida ulanish)
const sub = new Redis(process.env.REDIS_URL);
sub.subscribe("yangiliklar");
sub.on("message", (channel, message) => {
  console.log("Yangi xabar:", JSON.parse(message));   // barcha obunachilar oladi
});

   Keshlash yaxshi:
  - Tez-tez o'qiladigan, kam o'zgaradigan (mahsulot ro'yxati, sozlamalar)
  - Og'ir hisoblash natijasi (statistika, agregatsiya — 6)
  - Tashqi API javobi (sekin/pulli)

   Keshlash yomon/ehtiyot:
  - Tez-tez o'zgaradigan (real-time narx) — eski ko'rsatadi
  - Har foydalanuvchiga xos maxfiy (ehtiyot — 14)
  - Bir marta o'qiladigan (kesh foydasi yo'q)

   Redis'ga parol/auth (production — 14); tashqariga ochiq qoldirma
   Kalit nomi konvensiyasi (user:7, product:42, otp:998... — 2.4)
   TTL ber (xotira to'lib qolmasin — 2.7); maxmemory policy (eskini o'chirish)
   Maxfiy ma'lumotni ehtiyot (kerak bo'lsa shifrla — 14)
   Katta qiymatdan saqlan (Redis — kichik, tez ma'lumot uchun)
   Redis URL .env'da 5.8-bob; ulanish xatosini boshqar 5.10-bob
   Kesh "fail-open" — Redis yiqilsa, DB'dan ishla (ilova to'xtamasin)

import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL);    // (5.8)

// String + TTL (2.4, 2.7)
await redis.set("k", "v", "EX", 60);   await redis.get("k");   await redis.del("k");
await redis.incr("hisob");                          // atomik (2.11)

// Hash 2.9-bob: hset/hget/hgetall
// List 2.10-bob: lpush/rpush/lrange
// Set 2.10-bob: sadd/smembers
// Sorted Set 2.10-bob: zadd/zrevrange

// Cache-aside (2.5)
const k = await redis.get(key); if (k) return JSON.parse(k);
const d = await DB...; await redis.set(key, JSON.stringify(d), "EX", 3600);

// Pub/Sub 2.13-bob: publish / subscribe + on("message")

import Redis from "ioredis";
import { config } from "./config/index.js";         // (5.8)

export const redis = new Redis(config.redis.url);    // bir marta

redis.on("connect", () => console.log(" Redis ulandi"));   // (5.12)
redis.on("error", (err) => console.error("Redis xato:", err));   // (5.10)

// Asosiy amallar (2.4)
await redis.set("test", "salom", "EX", 60);          // TTL bilan
const q = await redis.get("test");                    // "salom"
await redis.incr("tashriflar");                       // atomik (2.11)

const KESH_MUDDAT = 3600;                            // 1 soat

export async function mahsulotOl(id) {
  const kalit = `product:${id}`;

  // 1. Redis'dan qidir (2.5)
  const kesh = await redis.get(kalit);
  if (kesh) {
    console.log("Cache HIT");                         // tez!
    return JSON.parse(kesh);
  }

  // 2. Cache miss  DB'dan (6)
  console.log("Cache MISS");
  const mahsulot = await Product.findById(id);
  if (!mahsulot) return null;

  // 3. Redis'ga sakla (keyingi safar uchun — 2.5)
  await redis.set(kalit, JSON.stringify(mahsulot), "EX", KESH_MUDDAT);
  return mahsulot;
}

// O'zgartirishda keshni o'chirish (eski qolmasin — 2.6)
export async function mahsulotYangila(id, data) {
  const mahsulot = await Product.findByIdAndUpdate(id, data, { new: true });   // DB (6)
  await redis.del(`product:${id}`);                  // keshni o'chir (2.6)
  // Ro'yxat keshini ham (agar bor bo'lsa)
  await redis.del("products:all");
  return mahsulot;
}

export async function mahsulotOchir(id) {
  await Product.findByIdAndDelete(id);
  await redis.del(`product:${id}`);                  // kesh ham (2.6)
  await redis.del("products:all");
}

// Universal kesh middleware (GET so'rovlar uchun — 5.6, 2.5)
export const cache = (muddat = 300) => async (req, res, next) => {
  const kalit = `cache:${req.originalUrl}`;          // URL bo'yicha kalit

  const kesh = await redis.get(kalit);
  if (kesh) {
    return res.json(JSON.parse(kesh));                // cache hit (tez!)
  }

  // res.json'ni "ushlab", keshlash uchun o'rab olamiz
  const aslJson = res.json.bind(res);
  res.json = (data) => {
    redis.set(kalit, JSON.stringify(data), "EX", muddat);   // keshla (2.7)
    return aslJson(data);
  };
  next();
};

// Ishlatish (5.6)
app.get("/api/products", cache(600), getProducts);   // 10 daqiqa kesh

// HASH — foydalanuvchi profili (2.9)
await redis.hset(`user:${id}`, { ism: "Ali", email: "ali@a.uz" });
const profil = await redis.hgetall(`user:${id}`);    // { ism, email }

// SET — online foydalanuvchilar (5.13, 2.10)
await redis.sadd("online", userId);                  // qo'sh (takrorlanmas)
await redis.srem("online", userId);                  // o'chir (disconnect)
const online = await redis.smembers("online");        // ro'yxat
const soni = await redis.scard("online");            // soni

// SORTED SET — reyting (leaderboard — 2.10)
await redis.zincrby("reyting", 10, userId);          // ball +10
const top10 = await redis.zrevrange("reyting", 0, 9, "WITHSCORES");  // top 10

// Post ko'rishlari (atomik — race condition yo'q — 2.11)
export async function korishQoshil(postId) {
  return redis.incr(`views:post:${postId}`);         // atomik +1
}

// Rate limiting (oddiy — 5.20 ruhida, 2.11)
export async function rateLimit(ip, limit = 100, window = 900) {
  const kalit = `rate:${ip}`;
  const soni = await redis.incr(kalit);
  if (soni === 1) await redis.expire(kalit, window);  // birinchi so'rovda TTL
  return soni <= limit;                               // chegaradan oshmaganmi
}

// OTP — Redis TTL bilan (5.18, 2.7)
export async function otpSaqla(telefon, kodHash) {
  await redis.set(`otp:${telefon}`, kodHash, "EX", 120);   // 2 daqiqa (avtomatik o'chadi)
  await redis.set(`otp:attempts:${telefon}`, "0", "EX", 120);
}
export async function otpOl(telefon) {
  return redis.get(`otp:${telefon}`);                 // null bo'lsa — muddat tugagan
}
export async function otpOchir(telefon) {
  await redis.del(`otp:${telefon}`, `otp:attempts:${telefon}`);   // ishlatilgach (5.18)
}

import Redis from "ioredis";

// Nashr qiluvchi (asosiy ulanish)
export async function elonQil(kanal, data) {
  await redis.publish(kanal, JSON.stringify(data));   // (2.13)
}

// Obunachi (ALOHIDA ulanish kerak — subscribe rejimida boshqa buyruq ishlamaydi)
const subscriber = new Redis(config.redis.url);
subscriber.subscribe("buyurtmalar", "bildirishnomalar");
subscriber.on("message", (kanal, xabar) => {
  const data = JSON.parse(xabar);
  if (kanal === "buyurtmalar") console.log("Yangi buyurtma:", data);
  // Socket.io orqali clientlarga (5.13)
});

// Redis ishlamasa ham, ilova to'xtamasin (DB'dan ishla — 2.15)
export async function xavfsizKeshOl(id) {
  try {
    const kesh = await redis.get(`product:${id}`);
    if (kesh) return JSON.parse(kesh);
  } catch (err) {
    console.error("Redis o'qishda xato (DB'dan davom):", err.message);   // (5.12)
    // Redis yiqildi — to'xtamaymiz, DB'dan olamiz
  }
  const mahsulot = await Product.findById(id);         // DB (6) — har doim ishlaydi
  redis.set(`product:${id}`, JSON.stringify(mahsulot), "EX", 3600)
    .catch(() => {});                                  // keshlash xato bersa, e'tiborsiz
  return mahsulot;
}

// Ko'p amalni bitta so'rovda (tarmoq tejaydi — performance)
const pipeline = redis.pipeline();
pipeline.set("a", "1");
pipeline.incr("hisob");
pipeline.expire("a", 60);
pipeline.hgetall("user:7");
const natijalar = await pipeline.exec();              // hammasi birga bajariladi
//  4 ta alohida so'rov o'rniga 1 ta (tarmoq sayohati kam — tezroq)

//  ma'lumot o'zgardi, kesh eski (foydalanuvchi eski ko'radi — 2.6)
await Product.findByIdAndUpdate(id, data);

//  keshni o'chir
await Product.findByIdAndUpdate(id, data);
await redis.del(`product:${id}`);

//  kesh abadiy (xotira to'ladi, eskirib qoladi — 2.7)
await redis.set(`product:${id}`, data);

//  TTL
await redis.set(`product:${id}`, data, "EX", 3600);

//  Redis xatosi butun so'rovni buzadi (2.15)
const kesh = await redis.get(key);   // Redis o'lik  500

//  fail-open (try/catch, DB'dan davom — Misol 9)

 tez-tez o'zgaradigan/maxfiy ma'lumotni ham keshlash (2.14)
 tanlab: tez-o'qiladigan, kam-o'zgaradigan (2.14)

//  obyektni to'g'ridan (Redis faqat string)
await redis.set("user", { ism: "Ali" });   // "[object Object]"!

//  JSON.stringify / parse
await redis.set("user", JSON.stringify({ ism: "Ali" }));
JSON.parse(await redis.get("user"));