Bulk va uzoq davom etuvchi operatsiyalar: 207 Multi-Status, 202 Accepted va polling

PUT /v1/vazifalar
Content-Type: application/json

{ "vazifalar": [
    { "id": 5, "matn": "Import #uy", "bajarildi": false },
    { "matn": "Non, sut va \"qatiq\"", "bajarildi": true }
] }

function validate(item) {
  const text = typeof item?.matn === "string" ? item.matn.trim() : "";
  if (text.length < 1 || text.length > 200) {
    return "matn 1–200 belgi bo'lishi kerak";
  }
  return null;
}

function bulkCreate(items, nextId) {
  const results = items.map((item, index) => {
    const error = validate(item);
    if (error) {
      return {
        index, status: 422,
        error: { joy: `body.vazifalar[${index}]`, xabar: error },
      };
    }
    return { index, status: 201, task: { id: nextId++, ...item } };
  });
  const allOk = results.every((r) => r.status === 201);
  return { status: allOk ? 201 : 207, body: { results } };
}

const res = bulkCreate(
  [{ matn: "A #ish" }, { matn: "" }, { matn: "B", bajarildi: true }],
  7,
);
console.log(res.status);
for (const r of res.body.results) {
  console.log(r.index, r.status, r.task?.id ?? r.error.xabar);
}

207
0 201 7
1 422 matn 1–200 belgi bo'lishi kerak
2 201 8

HTTP/1.1 207 Multi-Status
{"natijalar":[{"indeks":0,"holat":201,"vazifa":{"id":7,"matn":"A #ish",…}},
 {"indeks":1,"holat":422,"xato":{"joy":"body.vazifalar[1]","xabar":"matn 1–200 belgi bo'lishi kerak"}},
 {"indeks":2,"holat":201,"vazifa":{"id":8,"matn":"B","bajarildi":true,…}}]}

import { createServer } from "node:http";
import { setImmediate as yieldLoop } from "node:timers/promises";

const tasks = Array.from(
  { length: 250 }, (_, i) => `Vazifa ${i + 1}`,
);
const jobs = new Map();
let nextId = 1;

async function runExport(job) {
  for (let i = 0; i < tasks.length; i += 100) {
    await yieldLoop(); // event loop'ni bo'shatamiz
    job.state = "running";
    const chunk = tasks.slice(i, i + 100);
    job.csv += chunk.map((t, k) => `${i + k + 1},${t}\r\n`).join("");
    job.done += chunk.length;
  }
  job.state = "ready";
}

function view(job) {
  const v = { id: job.id, state: job.state, done: job.done };
  if (job.state === "ready") v.file = `/v1/eksportlar/${job.id}/fayl`;
  return v;
}

const server = createServer((req, res) => {
  const send = (status, body, headers = {}) => {
    const all = { "content-type": "application/json", ...headers };
    res.writeHead(status, all);
    res.end(JSON.stringify(body));
  };
  if (req.method === "POST" && req.url === "/v1/eksportlar") {
    const id = String(nextId++);
    const job = { id, state: "queued", done: 0, csv: "" };
    jobs.set(id, job);
    void runExport(job); // kutmaymiz — ish fonda
    return send(202, view(job), {
      location: `/v1/eksportlar/${id}`, "retry-after": "1",
    });
  }
  const m = /^\/v1\/eksportlar\/(\d+)(\/fayl)?$/.exec(req.url);
  const job = m && jobs.get(m[1]);
  if (!job) return send(404, { title: "Not Found" });
  if (m[2]) {
    res.writeHead(200, { "content-type": "text/csv" });
    return res.end(job.csv);
  }
  const wait = job.state === "ready" ? {} : { "retry-after": "1" };
  send(200, view(job), wait);
});
await new Promise((ok) => server.listen(0, "127.0.0.1", ok));
const base = `http://127.0.0.1:${server.address().port}`;

const start = await fetch(`${base}/v1/eksportlar`, {
  method: "POST",
});
const where = start.headers.get("location");
console.log(start.status, where, await start.json());
let info;
do {
  // namunada 20 ms — haqiqiy mijoz Retry-After ni kutadi
  await new Promise((ok) => setTimeout(ok, 20));
  info = await (await fetch(base + where)).json();
} while (info.state !== "ready");
console.log(info);
const csv = await (await fetch(base + info.file)).text();
const lines = csv.split("\r\n").filter(Boolean);
console.log(lines.length, "qator;", lines[0], "…", lines.at(-1));
server.closeAllConnections();
server.close();

202 /v1/eksportlar/1 { id: '1', state: 'queued', done: 0 }
{ id: '1', state: 'ready', done: 250, file: '/v1/eksportlar/1/fayl' }
250 qator; 1,Vazifa 1 … 250,Vazifa 250

bajar(ish).catch((x: unknown) => {
  ish.holat = "xato";
  ish.xato = "Eksport bajarilmadi";
  console.error(`[eksport ${ish.id}]`, x);
});
res.status(202).location(`${req.baseUrl}/${ish.id}`)
  .set("Retry-After", "1").json(korinish(ish, req.baseUrl));

function csvField(x) {
  const s = String(x);
  return /[",\r\n]/.test(s) ? `"${s.replaceAll('"', '""')}"` : s;
}

function csvRow(fields) {
  return fields.map(csvField).join(",") + "\r\n";
}

const row = csvRow([6, 'Non, sut va "qatiq"', true, ""]);
console.log(JSON.stringify(row));
console.log(csvRow(["oddiy", 42]).trim());

"6,\"Non, sut va \"\"qatiq\"\"\",true,\r\n"
oddiy,42

r.route("/")
  // ... GET, POST
  // PUT to'plamga — butun ro'yxatni almashtirish;
  // atomik: bitta xato bo'lsa hech narsa yozilmaydi
  .put(jsonKerak, async (req, res) => {
    const t = toplamniTekshir(req.body);
    if (!t.ok) throw new HttpXato(422,
      `${String(t.xatolar.length)} ta element noto'g'ri`,
      { kod: "validatsiya", xatolar: t.xatolar });
    const { vazifalar, versiya } =
      await xizmat.almashtirHammasi(t.qiymat);
    keshYoq(res);
    res.json({ versiya, vazifalar });
  })
  .all(metodYoq("GET, HEAD, POST, PUT"));

// /:id dan OLDIN — aks holda "toplam" id deb olinadi
r.route("/toplam")
  .post(jsonKerak, async (req, res) => {
    const tana: unknown = req.body;
    const elementlar =
      typeof tana === "object" && tana !== null
      && "vazifalar" in tana && Array.isArray(tana.vazifalar)
        ? (tana.vazifalar as unknown[]) : undefined;
    if (elementlar === undefined || elementlar.length === 0
      || elementlar.length > 100) {
      throw validatsiyaXatosi("body.vazifalar",
        "1..100 elementli massiv");
    }
    const tekshirilgan =
      elementlar.map((el) => yangiVazifaniTekshir(el));
    const yaroqli =
      tekshirilgan.flatMap((t) => (t.ok ? [t.qiymat] : []));
    const yaratilgan = await xizmat.toplamYarat(yaroqli);
    let k = 0;
    const natijalar = tekshirilgan.map((t, indeks): {
      indeks: number; holat: number; vazifa?: Vazifa;
      xato?: MaydonXatosi;
    } => {
      if (!t.ok) {
        return { indeks, holat: 422,
          xato: { joy: `body.vazifalar[${String(indeks)}]`,
            xabar: t.xato } };
      }
      const vazifa = yaratilgan[k++];
      return vazifa === undefined
        ? { indeks, holat: 500 } : { indeks, holat: 201, vazifa };
    });
    const hammasiOk = natijalar.every((n) => n.holat === 201);
    res.status(hammasiOk ? 201 : 207).json({ natijalar });
  })
  .all(metodYoq("POST"));

res.json({
  versiya: natija.versiya,
  vazifalar: natija.vazifalar.map((v) => proyeksiya(v, maydonlar)),
  sahifa,
});

export type AlmashtirishVazifasi = {
  id?: number; matn: string; bajarildi: boolean;
};

// RoyxatNatija ichiga:
  /** butun to'plam versiyasi (har yozuvda +1) — frontend sinxroni
   *  (22-qism `versiya`) va ro'yxat ETag'i uchun */
  versiya: number;

// VazifaOmbori ichiga:
  /** Butun to'plamni almashtirish (PUT /v1/vazifalar): berilgan
   *  yaroqli takrorlanmas id saqlanadi, qolganiga yangi id. Atomik */
  almashtirHammasi(vazifalar: readonly AlmashtirishVazifasi[]):
    Promise<{ vazifalar: Vazifa[]; versiya: number }>;

almashtirHammasi(yangilar: readonly AlmashtirishVazifasi[]):
  Promise<{ vazifalar: Vazifa[]; versiya: number }> {
  const hozir = this.#soat().toISOString();
  const band = new Set<number>();
  for (const y of yangilar) {
    if (y.id !== undefined && !band.has(y.id)) band.add(y.id);
  }
  let keyingi = Math.max(this.#keyingiId,
    ...[...band].map((id) => id + 1));
  const ishlatildi = new Set<number>();
  const eski = this.#vazifalar;
  const yangi = new Map<number, Vazifa>();
  for (const y of yangilar) {
    const id = y.id !== undefined && !ishlatildi.has(y.id)
      ? y.id : keyingi++;
    ishlatildi.add(id);
    const avval = eski.get(id);
    yangi.set(id, {
      id,
      matn: y.matn,
      bajarildi: y.bajarildi,
      teglar: teglariniOl(y.matn),
      yaratildi: avval?.yaratildi ?? hozir,
      yangilandi: hozir,
      versiya: (avval?.versiya ?? 0) + 1,
    });
  }
  eski.clear();
  for (const [id, v] of yangi) eski.set(id, v);
  this.#keyingiId = keyingi;
  this.#versiya++;
  return Promise.resolve({
    vazifalar: structuredClone([...yangi.values()]),
    versiya: this.#versiya,
  });
}

/** PUT /v1/vazifalar — butun to'plam (frontend "almashtir") */
almashtirHammasi: (vazifalar: readonly AlmashtirishVazifasi[]) =>
  ombor.almashtirHammasi(vazifalar),
/** Bulk yaratish: yaroqlilari yaratiladi, qolganlari — xato bilan */
async toplamYarat(yangilar: readonly YangiVazifa[]):
  Promise<Vazifa[]> {
  if ((await ombor.soni({})) + yangilar.length > MAKS_VAZIFA) {
    throw new HttpXato(409,
      `Ro'yxat to'ladi (${String(MAKS_VAZIFA)})`,
      { kod: "royxat-toldi", sarlavha: "Vazifalar soni chegarada" });
  }
  const yaratilgan: Vazifa[] = [];
  // Ketma-ket, tranzaksiyasiz: xotirada xato bo'lmaydi;
  // Postgres'da (26-qism) bitta tranzaksiya
  for (const y of yangilar) yaratilgan.push(await ombor.yarat(y));
  return yaratilgan;
},

export const MAKS_TOPLAM = 1000;
export type AlmashtirishElementi = {
  id?: number; matn: string; bajarildi: boolean;
};
type Xatolar = { joy: string; xabar: string }[];

/** PUT /v1/vazifalar tanasi:
 *  { vazifalar: [{ id?, matn, bajarildi }] }
 *  — har element joyi bilan xato */
export function toplamniTekshir(tana: unknown):
  | { ok: true; qiymat: AlmashtirishElementi[] }
  | { ok: false; xatolar: Xatolar } {
  if (!obyektmi(tana) || !Array.isArray(tana.vazifalar)) {
    return { ok: false, xatolar: [
      { joy: "body.vazifalar", xabar: "massiv bo'lishi kerak" }] };
  }
  if (tana.vazifalar.length > MAKS_TOPLAM) {
    return { ok: false, xatolar: [{ joy: "body.vazifalar",
      xabar: `ko'pi bilan ${String(MAKS_TOPLAM)} ta` }] };
  }
  const xatolar: Xatolar = [];
  const natija: AlmashtirishElementi[] = [];
  for (const [i, el] of (tana.vazifalar as unknown[]).entries()) {
    const joy = `body.vazifalar[${String(i)}]`;
    if (!obyektmi(el)) {
      xatolar.push({ joy, xabar: "obyekt bo'lishi kerak" });
      continue;
    }
    const { id, ...qolgan } = el;
    if (id !== undefined && !(typeof id === "number"
      && Number.isSafeInteger(id) && id > 0)) {
      xatolar.push({ joy: `${joy}.id`, xabar: "musbat butun son" });
    }
    const t = toliqVazifaniTekshir(qolgan);
    if (!t.ok) xatolar.push({ joy, xabar: t.xato });
    else natija.push(typeof id === "number"
      ? { id, ...t.qiymat } : t.qiymat);
  }
  return xatolar.length > 0
    ? { ok: false, xatolar } : { ok: true, qiymat: natija };
}

// eksport.ts — uzoq davom etuvchi operatsiya: POST → 202 Accepted
// + Location (holat resursi), mijoz so'rab turadi (polling), tayyor
// bo'lganda natija fayli havolasi. Ishlar xotirada (bitta jarayon);
// ko'p jarayon/qayta ishga tushish — navbat (BullMQ, 27/29-qism)
import { randomUUID } from "node:crypto";
import { setImmediate as navbat } from "node:timers/promises";
import { Router } from "express";
import { HttpXato } from "../umumiy/http-xato.ts";
import { csvQator } from "../umumiy/csv.ts";
import type { KursorQiymati, VazifaOmbori }
  from "../vazifalar/ombor.ts";

export type EksportHolati =
  "kutilmoqda" | "bajarilmoqda" | "tayyor" | "xato";
type Ish = {
  id: string; holat: EksportHolati; yaratildi: string;
  tayyor: number; jami: number; csv?: string; xato?: string;
  tugash: number;
};

const SAQLASH_MS = 60 * 60 * 1000; // natija 1 soat saqlanadi
const BOLAK = 100;

export function eksportRouteri(
  ombor: VazifaOmbori,
  {
    soat = Date.now,
    bolakdanKeyin = (): Promise<void> => navbat(),
  } = {},
): Router {
  const ishlar = new Map<string, Ish>();
  const r = Router();

  async function bajar(ish: Ish): Promise<void> {
    ish.holat = "bajarilmoqda";
    ish.jami = await ombor.soni({});
    let csv = csvQator(["id", "matn", "bajarildi", "teglar",
      "yaratildi", "yangilandi"]);
    let keyin: KursorQiymati | undefined;
    for (;;) {
      const n = await ombor.royxat({
        filtr: {}, saralash: [], limit: BOLAK,
        sahifa: keyin === undefined
          ? { tur: "kursor" } : { tur: "kursor", keyin },
      });
      for (const v of n.vazifalar) {
        csv += csvQator([v.id, v.matn, v.bajarildi,
          v.teglar.join(" "), v.yaratildi, v.yangilandi]);
      }
      ish.tayyor += n.vazifalar.length;
      if (!n.borKeyingi || n.keyingi === undefined) break;
      keyin = n.keyingi;
      // event loop'ni bo'shatamiz — boshqa so'rovlar kutib qolmasin
      await bolakdanKeyin();
    }
    ish.csv = csv;
    ish.holat = "tayyor";
    ish.tugash = soat() + SAQLASH_MS;
  }

  function topilsin(id: string): Ish {
    for (const [k, i] of ishlar) {
      if (i.tugash <= soat()) ishlar.delete(k);
    }
    const ish = ishlar.get(id);
    if (ish === undefined) {
      throw new HttpXato(404,
        `Eksport ${id} topilmadi (yoki muddati o'tgan)`,
        { kod: "eksport-topilmadi", sarlavha: "Eksport topilmadi" });
    }
    return ish;
  }

  function korinish(ish: Ish, asos: string): Record<string, unknown> {
    const k: Record<string, unknown> = {
      id: ish.id, holat: ish.holat, yaratildi: ish.yaratildi,
      tayyor: ish.tayyor, jami: ish.jami,
    };
    if (ish.holat === "tayyor") k.fayl = `${asos}/${ish.id}/fayl`;
    if (ish.xato !== undefined) k.xato = ish.xato;
    return k;
  }

  r.post("/", (req, res) => {
    const ish: Ish = {
      id: randomUUID(), holat: "kutilmoqda",
      yaratildi: new Date(soat()).toISOString(),
      tayyor: 0, jami: 0, tugash: soat() + SAQLASH_MS,
    };
    ishlar.set(ish.id, ish);
    // Javob kutmaydi: ish fonda; xatosi ish holatiga yoziladi
    // (yutib yuborilmaydi)
    bajar(ish).catch((x: unknown) => {
      ish.holat = "xato";
      ish.xato = "Eksport bajarilmadi";
      console.error(`[eksport ${ish.id}]`, x);
    });
    res.status(202).location(`${req.baseUrl}/${ish.id}`)
      .set("Retry-After", "1").json(korinish(ish, req.baseUrl));
  });

  r.get("/:id", (req, res) => {
    const ish = topilsin(req.params.id);
    if (ish.holat === "kutilmoqda" || ish.holat === "bajarilmoqda") {
      res.set("Retry-After", "1");
    }
    res.set("Cache-Control", "no-store")
      .json(korinish(ish, req.baseUrl));
  });

  r.get("/:id/fayl", (req, res) => {
    const ish = topilsin(req.params.id);
    if (ish.csv === undefined) {
      throw new HttpXato(409, "Eksport hali tayyor emas", {
        kod: "eksport-tayyor-emas", sarlavha: "Eksport tayyor emas",
        httpSarlavhalar: { "Retry-After": "1" },
      });
    }
    res.attachment(`vazifalar-${ish.yaratildi.slice(0, 10)}.csv`)
      .type("text/csv; charset=utf-8").send(ish.csv);
  });

  return r;
}

// csv.ts — RFC 4180: vergul, qo'shtirnoq yoki yangi qator bo'lsa —
// qo'shtirnoq ichida, " → ""
export function csvMaydon(x: string | number | boolean): string {
  const s = String(x);
  return /[",\r\n]/.test(s) ? `"${s.replaceAll('"', '""')}"` : s;
}

export function csvQator(
  maydonlar: readonly (string | number | boolean)[],
): string {
  return maydonlar.map(csvMaydon).join(",") + "\r\n";
}

curl -i -X POST $A/v1/eksportlar
curl $A/v1/eksportlar/<id>
curl -i $A/v1/eksportlar/<id>/fayl

HTTP/1.1 202 Accepted
Location: /v1/eksportlar/f4c82bf5-e649-45f1-83a4-cd1f8cf6cd66
Retry-After: 1
{"id":"f4c82bf5-…","holat":"bajarilmoqda","yaratildi":"2026-10-24T05:32:00.630Z","tayyor":0,"jami":0}

{"id":"4255e71a-…","holat":"tayyor","yaratildi":"2026-10-24T05:32:00.826Z","tayyor":4,"jami":4,"fayl":"/v1/eksportlar/4255e71a-…/fayl"}

HTTP/1.1 200 OK
Content-Type: text/csv; charset=utf-8
Content-Disposition: attachment; filename=vazifalar-2026-10-24.csv

id,matn,bajarildi,teglar,yaratildi,yangilandi
5,Import #uy,false,uy,2026-10-24T05:32:00.108Z,2026-10-24T05:32:00.108Z
6,"Non, sut va ""qatiq""",true,,2026-10-24T05:32:00.108Z,2026-10-24T05:32:00.108Z
7,A #ish,false,ish,2026-10-24T05:32:00.371Z,2026-10-24T05:32:00.371Z
8,B,true,,2026-10-24T05:32:00.371Z,2026-10-24T05:32:00.371Z