Backend'da sana va vaqt: UTC'da saqlash, Asia/Tashkent kuni va Temporal

assert.match(v.yaratildi,
  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);

new Date("2026-10-24")            → 2026-10-24T00:00:00.000Z (sana-only satr — UTC deb o'qiladi)
new Date("2026-10-24T00:00")      → 2026-10-23T19:00:00.000Z (vaqtli, Z siz — MAHALLIY: TZ=tizim, Asia/Tashkent)
new Date(2026, 9, 24)             → 2026-10-23T19:00:00.000Z (oy 0 dan; mahalliy)
new Date("2026-02-30")            → Mon Mar 02 2026 05:00:00 GMT+0500 (Uzbekistan Standard Time); Date.UTC(2026,1,30) → 2026-03-02T00:00:00.000Z (jim to'g'rilaydi)
UTC lahza 2026-10-23T19:30:00.000Z → getDate() 24 (jarayon mintaqasi), getUTCDate() 23
TZ=UTC              getDate/getHours: 23 19 Fri Oct 23 2026 19:30:00 GMT+0000 (Coordinated Universal Time)
TZ=Asia/Tashkent    getDate/getHours: 24 0 Sat Oct 24 2026 00:30:00 GMT+0500 (Uzbekistan Standard Time)
TZ=America/New_York getDate/getHours: 23 15 Fri Oct 23 2026 15:30:00 GMT-0400 (Eastern Daylight Time)

function haqiqiySana(x) {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(x)) return false;
  const t = Date.parse(`${x}T00:00:00Z`);
  return !Number.isNaN(t) && new Date(t).toISOString().startsWith(x);
}

for (const x of ["2026-10-24", "2026-02-30", "2028-02-29",
  "2026-2-5", "2026-13-01"]) {
  console.log(x, haqiqiySana(x));
}

2026-10-24 true
2026-02-30 false
2028-02-29 true
2026-2-5 false
2026-13-01 false

$ curl $A/v1/vazifalar?dan=2026-02-30
{"type":"https://vazifalar-api.example/xatolar/parametr","title":"Parametr noto'g'ri","status":400,"detail":"dan — YYYY-MM-DD (haqiqiy sana)",…}

function siljish(tz, lahza) {
  const q = new Intl.DateTimeFormat("en-US", {
    timeZone: tz, hourCycle: "h23",
    year: "numeric", month: "2-digit", day: "2-digit",
    hour: "2-digit", minute: "2-digit", second: "2-digit",
  }).formatToParts(lahza);
  const ol = (tur) => Number(q.find((p) => p.type === tur)?.value);
  const mahalliy = Date.UTC(ol("year"), ol("month") - 1, ol("day"),
    ol("hour"), ol("minute"), ol("second"));
  const butun = Math.floor(lahza.getTime() / 1000) * 1000;
  return Math.round((mahalliy - butun) / 60_000);
}

function kunBoshiUtc(sana, tz) {
  const [y, m, d] = sana.split("-").map(Number);
  const taxmin = Date.UTC(y, m - 1, d);
  const birinchi = taxmin - siljish(tz, new Date(taxmin)) * 60_000;
  const s = siljish(tz, new Date(birinchi));
  return new Date(taxmin - s * 60_000).toISOString();
}

console.log(siljish("Asia/Tashkent", new Date("2026-10-24T00:00Z")));
console.log(kunBoshiUtc("2026-10-24", "Asia/Tashkent"));
console.log(kunBoshiUtc("2026-07-01", "America/New_York"));
console.log(kunBoshiUtc("2026-12-01", "America/New_York"));

300
2026-10-23T19:00:00.000Z
2026-07-01T04:00:00.000Z
2026-12-01T05:00:00.000Z

if (q.dan !== undefined) filtr.yaratildiDan = kunBoshiUtc(q.dan, tz);
if (q.gacha !== undefined)
  filtr.yaratildiGacha = kunBoshiUtc(keyingiKun(q.gacha), tz);

assert.deepEqual(await ol("dan=2026-10-24&gacha=2026-10-24"),
  ["yarim tundan keyin"]);
assert.deepEqual(await ol("gacha=2026-10-23"), ["kech"]);
assert.equal((await fetch(`${asos}/v1/vazifalar?dan=2026-02-30`))
  .status, 400);

uz          shanba, 24-oktabr, 2026, 00:30
uz-Latn-UZ  shanba, 24-oktabr, 2026, 00:30
uz-Cyrl-UZ  шанба, 24 октябр, 2026 00:30
ru-RU       суббота, 24 октября 2026 г. в 00:30
en-GB       Saturday, 24 October 2026 at 00:30
uz, month long: 24-oktabr; resolvedOptions: "uz"
RelativeTimeFormat uz: kecha, 3 soatdan keyin
ICU: 78.3, CLDR 48.0, tz 2026c

typeof Temporal: undefined
node --harmony-temporal: exit 0 object 2026-10-23T19:30:00Z
node --js-temporal: exit 9 …node.exe: bad option: --js-temporal

// node --harmony-temporal
const z = Temporal.ZonedDateTime.from(
  "2026-10-24T00:30[Asia/Tashkent]");
console.log(z.toInstant().toString());
const kun = Temporal.PlainDate.from("2026-10-24");
const bosh = kun.toZonedDateTime("Asia/Tashkent").toInstant();
console.log(bosh.toString());

2026-10-23T19:30:00Z
2026-10-23T19:00:00Z

// sana.ts — saqlash UTC'da, foydalanuvchi esa "24-oktabr" deganda
// Toshkent kunini nazarda tutadi.
// Mahalliy kun chegarasi → UTC lahza (Temporal Node 24 da yo'q — Intl
// bilan)

/**
 * tz mintaqasining berilgan UTC lahzadagi siljishi (daqiqa):
 * Asia/Tashkent → +300
 */
export function siljish(tz: string, lahza: Date): number {
  const qismlar = new Intl.DateTimeFormat("en-US", {
    timeZone: tz,
    hourCycle: "h23",
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
    hour: "2-digit",
    minute: "2-digit",
    second: "2-digit",
  }).formatToParts(lahza);
  const q = (tur: Intl.DateTimeFormatPartTypes): number =>
    Number(qismlar.find((p) => p.type === tur)?.value);
  const mahalliy = Date.UTC(
    q("year"),
    q("month") - 1,
    q("day"),
    q("hour"),
    q("minute"),
    q("second"),
  );
  return Math.round(
    (mahalliy - Math.floor(lahza.getTime() / 1000) * 1000) / 60_000,
  );
}

/**
 * "2026-10-24" (tz bo'yicha kun) → shu kun boshlanishining UTC ISO
 * lahzasi: Toshkent → "2026-10-23T19:00:00.000Z"
 */
export function kunBoshiUtc(sana: string, tz: string): string {
  const [y, m, d] = sana.split("-").map(Number);
  const taxmin = Date.UTC(y ?? 0, (m ?? 1) - 1, d ?? 1);
  // DST bo'lgan mintaqalarda siljish kunga qarab o'zgaradi — ikki
  // marta hisoblaymiz
  const birinchi = taxmin - siljish(tz, new Date(taxmin)) * 60_000;
  return new Date(
    taxmin - siljish(tz, new Date(birinchi)) * 60_000,
  ).toISOString();
}

/** Keyingi kun (mahalliy kalendar bo'yicha) */
export function keyingiKun(sana: string): string {
  const [y, m, d] = sana.split("-").map(Number);
  return new Date(Date.UTC(y ?? 0, (m ?? 1) - 1, (d ?? 1) + 1))
    .toISOString()
    .slice(0, 10);
}

// sorov.ts — tekshirilgan ro'yxat query'sini (sxema.ts → RoyxatQuery)
// ombor so'roviga aylantirish: kursorni ochish, imzo, proyeksiya
// Konvensiya:
// ?bajarildi=true&teg=uy&teg=ish&q=non
// &sort=-yaratildi,matn&fields=id,matn&limit=20&offset=40
// | &cursor=...&jami=true
import { ParametrXatosi } from "../umumiy/xatolar.ts";
import { kursorOqi } from "../umumiy/kursor.ts";
import { keyingiKun, kunBoshiUtc } from "../umumiy/sana.ts";
import type { Filtr, RoyxatSorovi } from "./ombor.ts";
import type { Maydon, RoyxatQuery } from "./sxema.ts";
import type { Vazifa } from "./vazifa.ts";

export type TekshirilganSorov = {
  sorov: RoyxatSorovi;
  maydonlar?: Maydon[];
  imzo: string;
};

/**
 * @param tz foydalanuvchi kuni qaysi mintaqada (config APP_TZ) —
 * saqlangan vaqt esa UTC
 */
export function royxatSorovi(
  q: RoyxatQuery,
  tz = "Asia/Tashkent",
): TekshirilganSorov {
  const filtr: Filtr = {};
  if (q.dan !== undefined)
    filtr.yaratildiDan = kunBoshiUtc(q.dan, tz);
  if (q.gacha !== undefined)
    filtr.yaratildiGacha = kunBoshiUtc(keyingiKun(q.gacha), tz);
  if (q.bajarildi !== undefined) filtr.bajarildi = q.bajarildi;
  if (q.teg !== undefined) filtr.teglar = q.teg;
  if (q.q !== undefined) filtr.qidiruv = q.q;
  const saralash = q.sort ?? [];
  // Imzo — kursor boshqa filtr/saralash bilan qayta ishlatilmasin
  const imzo = JSON.stringify([saralash, filtr]);
  let sahifa: RoyxatSorovi["sahifa"];
  if (q.cursor !== undefined) {
    const keyin = kursorOqi(q.cursor, imzo);
    if (keyin === undefined)
      throw new ParametrXatosi(
        "cursor yaroqsiz yoki boshqa saralash/filtr uchun",
        [{ joy: "query.cursor", xabar: "yaroqsiz" }],
      );
    sahifa = { tur: "kursor", keyin };
  } else {
    // Parametrsiz — kursor rejimi (birinchi sahifa); offset faqat
    // aniq so'ralganda
    sahifa =
      q.offset === undefined
        ? { tur: "kursor" }
        : { tur: "offset", offset: q.offset };
  }
  const sorov: RoyxatSorovi = {
    filtr,
    saralash,
    limit: q.limit,
    sahifa,
  };
  if (q.jami !== undefined) sorov.jami = q.jami;
  return q.fields === undefined
    ? { sorov, imzo }
    : { sorov, maydonlar: q.fields, imzo };
}

/** Sparse fieldsets: faqat so'ralgan maydonlar */
export function proyeksiya(
  v: Vazifa,
  maydonlar: readonly Maydon[] | undefined,
): Partial<Vazifa> {
  if (maydonlar === undefined) return v;
  return Object.fromEntries(maydonlar.map((m) => [m, v[m]]));
}

--- a/sxema.ts
+++ b/sxema.ts
@@ -6,5 +6,7 @@
 import type { Saralash, SaralashMaydoni } from "./ombor.ts";
 
-export const MAKS_MATN = 200;
+// 22-qism frontend (Vazifa.MAKS_UZUNLIK) va 26-qism sxemasi (CHECK
+// 1–100) bilan bir xil
+export const MAKS_MATN = 100;
 export const MAKS_TOPLAM = 1000;
 export const SUKUT_LIMIT = 20;
@@ -96,4 +98,19 @@
     });
 const TEG = /^[\p{L}\p{N}_'‘’]{1,50}$/u;
+/**
+ * YYYY-MM-DD va haqiqiy kalendar sanasi (2026-02-30 — yo'q: Date uni
+ * 03-02 ga "to'g'rilab" yuboradi)
+ */
+function haqiqiySana(x: string): boolean {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(x)) return false;
+  const t = Date.parse(`${x}T00:00:00Z`);
+  return (
+    !Number.isNaN(t) && new Date(t).toISOString().startsWith(x)
+  );
+}
+const Sana = (nom: string) =>
+  Bitta(nom).refine(haqiqiySana, {
+    error: `${nom} — YYYY-MM-DD (haqiqiy sana)`,
+  });
 const MAYDONLAR = [
   "id",
@@ -101,4 +118,5 @@
   "bajarildi",
   "teglar",
+  "tartib",
   "yaratildi",
   "yangilandi",
@@ -189,4 +207,8 @@
       cursor: Bitta("cursor").max(1000).optional(),
       jami: Mantiqiy("jami").optional(),
+      // Mahalliy kalendar kuni (APP_TZ, sukut Asia/Tashkent):
+      // ?dan=2026-10-24&gacha=2026-10-24 — ikkalasi ham kiradi
+      dan: Sana("dan").optional(),
+      gacha: Sana("gacha").optional(),
     },
     {

--- a/marshrut.ts
+++ b/marshrut.ts
@@ -51,7 +51,10 @@
   return `${req.baseUrl}?${p.toString()}`;
 }
 
-export function vazifalarRouteri(xizmat: VazifaXizmati): Router {
+export function vazifalarRouteri(
+  xizmat: VazifaXizmati,
+  { tz = "Asia/Tashkent" } = {},
+): Router {
   const r = Router();
 
   r.route("/")
@@ -61,7 +64,10 @@
       tekshirib(
         { query: RoyxatQuerySxemasi },
         async ({ query }, req, res) => {
-          const { sorov, maydonlar, imzo } = royxatSorovi(query);
+          const { sorov, maydonlar, imzo } = royxatSorovi(
+            query,
+            tz,
+          );
           const natija = await xizmat.royxat(sorov);
           const sahifa: Record<string, unknown> = {
             limit: sorov.limit,

--- a/xato.test.ts
+++ b/xato.test.ts
@@ -49,13 +49,13 @@
     type: "https://vazifalar-api.example/xatolar/validatsiya",
     title: "So'rov ma'lumoti noto'g'ri",
     status: 422,
-    detail: "matn 1–200 belgi bo'lishi kerak",
+    detail: "matn 1–100 belgi bo'lishi kerak",
     instance: "/v1/vazifalar",
     kod: "validatsiya",
     xatolar: [
       {
         joy: "body.matn",
-        xabar: "matn 1–200 belgi bo'lishi kerak",
+        xabar: "matn 1–100 belgi bo'lishi kerak",
       },
     ],
     sorovId: r.headers.get("x-request-id"),

import { after, before, test } from "node:test";
import assert from "node:assert/strict";
import {
  keyingiKun,
  kunBoshiUtc,
  siljish,
} from "../src/umumiy/sana.ts";
import { ishgaTushir } from "../src/ishga-tushir.ts";
import { yop } from "../src/yopish.ts";
import { XotiraOmbori } from "../src/vazifalar/xotira-ombor.ts";

test("Toshkent kuni → UTC: 24-oktabr 00:00 (UTC+5) = 23-oktabr 19:00Z", () => {
  assert.equal(
    siljish("Asia/Tashkent", new Date("2026-10-24T00:00:00Z")),
    300,
  );
  assert.equal(
    kunBoshiUtc("2026-10-24", "Asia/Tashkent"),
    "2026-10-23T19:00:00.000Z",
  );
  assert.equal(
    kunBoshiUtc("2026-10-24", "UTC"),
    "2026-10-24T00:00:00.000Z",
  );
  assert.equal(keyingiKun("2026-12-31"), "2027-01-01");
});

test("DST bor mintaqa: Nyu-York yoz (UTC-4) va qish (UTC-5)", () => {
  assert.equal(
    kunBoshiUtc("2026-07-01", "America/New_York"),
    "2026-07-01T04:00:00.000Z",
  );
  assert.equal(
    kunBoshiUtc("2026-12-01", "America/New_York"),
    "2026-12-01T05:00:00.000Z",
  );
});

let asos = "";
let toxta: () => Promise<boolean>;
before(async () => {
  // Soxta soat: UTC 23-okt 18:30 (Toshkentda 23:30) va 19:30
  // (Toshkentda 24-okt 00:30)
  const vaqtlar = [
    "2026-10-23T18:30:00.000Z",
    "2026-10-23T19:30:00.000Z",
  ];
  const ombor = new XotiraOmbori(
    () => new Date(vaqtlar.shift() ?? "2026-10-25T00:00:00.000Z"),
  );
  await ombor.yarat({ matn: "kech" });
  await ombor.yarat({ matn: "yarim tundan keyin" });
  const { server, manzil } = await ishgaTushir({
    port: 0,
    bogliqliklar: { ombor, tz: "Asia/Tashkent" },
  });
  asos = manzil;
  toxta = () => yop(server, 1000);
});
after(() => toxta());

test("?dan=&gacha= — Toshkent kalendar kuni bo'yicha (UTC sanasi bo'yicha emas)", async () => {
  const ol = async (q: string) =>
    (
      (await (
        await fetch(`${asos}/v1/vazifalar?${q}&fields=matn`)
      ).json()) as { vazifalar: { matn: string }[] }
    ).vazifalar.map((v) => v.matn);
  assert.deepEqual(await ol("dan=2026-10-24&gacha=2026-10-24"), [
    "yarim tundan keyin",
  ]);
  assert.deepEqual(await ol("gacha=2026-10-23"), ["kech"]);
  assert.equal(
    (await fetch(`${asos}/v1/vazifalar?dan=2026-02-30`)).status,
    400,
  );
});

// ishga-tushir.ts — ombor tanlash (config bo'yicha), http server
// (Express ilovasi ishlovchi sifatida), timeout'lar va tinglash
import { createServer } from "node:http";
import type { Server } from "node:http";
import type { AddressInfo } from "node:net";
import { ilovaYarat } from "./ilova.ts";
import type { Bogliqliklar } from "./ilova.ts";
import type { Config } from "./config.ts";
import { XotiraOmbori } from "./vazifalar/xotira-ombor.ts";
import { FaylOmbori } from "./vazifalar/fayl-ombor.ts";
import type { VazifaOmbori } from "./vazifalar/ombor.ts";

export type Ishlayotgan = { server: Server; manzil: string };

/**
 * SAQLASH=xotira|fayl — 26-qismda shu yerga "postgres" (pg Pool)
 * qo'shiladi; qolgan kod VazifaOmbori interfeysini biladi, xolos
 */
export async function omborYarat(
  config: Pick<Config, "SAQLASH" | "FAYL_YOLI">,
): Promise<VazifaOmbori> {
  switch (config.SAQLASH) {
    case "xotira":
      return new XotiraOmbori();
    case "fayl":
      return FaylOmbori.och(config.FAYL_YOLI);
  }
}

type Sozlama = {
  port?: number;
  host?: string;
  bogliqliklar?: Bogliqliklar;
};

export async function ishgaTushir({
  port = 0,
  host = "127.0.0.1",
  bogliqliklar = { ombor: new XotiraOmbori() },
}: Sozlama = {}): Promise<Ishlayotgan> {
  // app.listen() ham shuni qiladi; createServer — timeout'larni
  // berish va server obyektini olish uchun
  const server = createServer(
    {
      // Load balancer (nginx, ALB) bo'sh ulanishni ~60 s ushlaydi —
      // Node undan KEYIN yopsin
      keepAliveTimeout: 65_000,
      // Slowloris: sarlavhalar 10 s ichida to'liq kelmasa — 408
      headersTimeout: 10_000,
      requestTimeout: 30_000,
    },
    ilovaYarat(bogliqliklar),
  );
  await new Promise<void>((resolve, reject) => {
    server.once("error", reject); // EADDRINUSE va h.k.
    server.listen(port, host, () => {
      server.off("error", reject);
      resolve();
    });
  });
  const { port: haqiqiy } = server.address() as AddressInfo;
  return { server, manzil: `http://${host}:${String(haqiqiy)}` };
}

$ curl $A/v1/vazifalar?dan=2026-10-24&fields=matn,yaratildi
{"versiya":1,"vazifalar":[{"id":1,"matn":"Bugungi vazifa #uy","yaratildi":"2026-10-24T05:55:46.307Z"}],"sahifa":{"limit":20,"keyingi":null}}
$ curl $A/v1/vazifalar?gacha=2026-01-01&fields=matn
{"versiya":1,"vazifalar":[],"sahifa":{"limit":20,"keyingi":null}}
--- SAQLASH=fayl: ikki marta ishga tushirish
$ curl 'http://127.0.0.1:4199/v1/vazifalar?fields=matn' (qayta ishga tushgandan keyin)
{"versiya":1,"vazifalar":[{"id":1,"matn":"diskda saqlanadi"}],"sahifa":{"limit":20,"keyingi":null}}
fayl: 208 bayt

npm run check

git add -A
git commit -m "Config: Zod bilan tipli va muzlatilgan, fail-fast (exit 78); .env.example; SAQLASH=fayl (atomik JSON); ?dan/?gacha Toshkent kuni; tartib; matn 100"