Node.js environment o'zgaruvchilar va .env: 12-factor config, NODE_ENV va .env.example

const { server, manzil } = await ishgaTushir({
  port: Number(process.env.PORT ?? 3000),
  host: process.env.HOST ?? "127.0.0.1",
  bogliqliklar: {
    ombor: new XotiraOmbori(),
    corsOriginlar: (process.env.CORS_ORIGINS ?? "")
      .split(",").map((o) => o.trim()).filter((o) => o !== ""),
  },
});

process.env.X = 3000;
process.env.Y = true;
process.env.Z = undefined;
console.log(typeof process.env.X, process.env.Y === true);
console.log(JSON.stringify(process.env.Z));
delete process.env.X;
console.log(process.env.X);

string false
"undefined"
undefined

PORT= node -e 'console.log(JSON.stringify(process.env.PORT),
  Number(process.env.PORT ?? 3000), Number(process.env.PORT || 3000))'

"" 0 3000

NODE_ENV=production npm config get omit
npm config get omit

dev

// ❌ "production'da to'lov haqiqiy, boshqa joyda soxta"
const tolov = process.env.NODE_ENV === "production"
  ? haqiqiyTolov : soxtaTolov;

// ✅ aniq sozlama — muhit nomiga emas, ma'noga bog'langan
const tolov = process.env.TOLOV_REJIMI === "haqiqiy"
  ? haqiqiyTolov : soxtaTolov;

# izoh
PORT=4100
XABAR="salom # bu izoh emas"
BOSH_JOY=  qiymat
IKKI_QATOR="birinchi\nikkinchi"
export EKSPORT=1
BOSH=
PORT=4200

PORT "4200"
XABAR "salom # bu izoh emas"
BOSH_JOY "qiymat"
IKKI_QATOR "birinchi\nikkinchi"
EKSPORT "1"
BOSH ""

import { parseEnv } from "node:util";

const matn = [
  "PORT=4100",
  "IZOHLI=qiymat # izoh",
  'XABAR="salom # izoh emas"',
  "PORT=4200",
].join("\n");
console.log(parseEnv(matn));

{ IZOHLI: 'qiymat', PORT: '4200', XABAR: 'salom # izoh emas' }

muhitda PORT=9999 bor + --env-file (qaysi ustun?): exit 0: 9999

node --env-file=.env --env-file=.env.local -e "…"
node --env-file=.env.local --env-file=.env -e "…"

4100 info
3000

--env-file=yoq.env: exit 9: …node.exe: yoq.env: not found
--env-file-if-exists=yoq.env: exit 0: ishladi

# .env.example — namuna (git'da). Nusxa: cp .env.example .env
# (.env git'ga KIRMAYDI — .gitignore)
# Bu yerda haqiqiy parol/kalit YO'Q va bo'lmasligi kerak.
# Hamma qiymat src/config.ts da Zod bilan tekshiriladi.

# development | production | test
NODE_ENV=development
PORT=3000
# Faqat lokal. Docker ichida 0.0.0.0 (33-qism)
HOST=127.0.0.1
# Frontend manzillari, vergul bilan (production'da majburiy)
CORS_ORIGINS=http://localhost:5173
# fatal | error | warn | info | debug | trace | silent
LOG_LEVEL=info
# xotira | fayl  (26-qismda: postgres)
SAQLASH=xotira
FAYL_YOLI=data/vazifalar.json
# Reverse proxy orqasida: proxy'lar soni (1) yoki false
TRUST_PROXY=false
# Foydalanuvchi sanalari (?dan=, ?gacha=) qaysi mintaqada
APP_TZ=Asia/Tashkent
# HTTPS orqasida (nginx) true
HSTS=false
# Vazifa bajarilganda xabar yuboriladigan manzil (ixtiyoriy)
# WEBHOOK_URL=https://example.com/webhook

git check-ignore -v .env: .gitignore:1:.env	.env

{
  "scripts": {
    "dev": "node --watch --env-file-if-exists=.env src/server.ts",
    "start": "node --env-file-if-exists=.env src/server.ts",
    "test": "node --test \"test/**/*.test.ts\""
  }
}

cp .env.example .env
git status --short
git check-ignore -v .env
npm run dev

--- a/vazifa.ts
+++ b/vazifa.ts
@@ -20,6 +20,11 @@
   yaratildi: string;
   yangilandi: string;
   /**
+   * ro'yxatdagi o'rni (frontend sudrab tartiblaydi → PUT
+   * /v1/vazifalar massiv tartibi); sukut saralash shu bo'yicha
+   */
+  tartib: number;
+  /**
    * har o'zgarishda +1 — ETag va If-Match (optimistic concurrency)
    * shundan
    */

--- a/ombor.ts
+++ b/ombor.ts
@@ -14,6 +14,7 @@
  */
 export const SARALASH_MAYDONLARI = [
   "id",
+  "tartib",
   "matn",
   "bajarildi",
   "yaratildi",
@@ -31,6 +32,10 @@
   teglar?: string[];
   /** matn ichida, katta-kichik harfsiz */
   qidiruv?: string;
+  /** yaratildi >= (UTC ISO lahza) */
+  yaratildiDan?: string;
+  /** yaratildi < (UTC ISO lahza, chegarasiz) */
+  yaratildiGacha?: string;
 };
 
 /**
@@ -46,8 +51,8 @@
 export type RoyxatSorovi = {
   filtr: Filtr;
   /**
-   * bo'sh bo'lsa — id bo'yicha o'sish;
-   * ombor oxiriga doim id qo'shadi
-   * (barqaror tartib)
+   * bo'sh bo'lsa — tartib, keyin id bo'yicha o'sish; ombor oxiriga
+   * doim id qo'shadi (barqaror tartib)
    */
   saralash: Saralash[];
   limit: number;

--- a/royxat-mantiq.ts
+++ b/royxat-mantiq.ts
@@ -23,7 +23,13 @@
       (filtr.teglar === undefined ||
         filtr.teglar.every((t) => v.teglar.includes(t))) &&
       (qidiruv === undefined ||
-        v.matn.toLowerCase().includes(qidiruv)),
+        v.matn.toLowerCase().includes(qidiruv)) &&
+      // ISO UTC satrlar (bir xil format, Z) leksikografik
+      // solishtirish = vaqt bo'yicha
+      (filtr.yaratildiDan === undefined ||
+        v.yaratildi >= filtr.yaratildiDan) &&
+      (filtr.yaratildiGacha === undefined ||
+        v.yaratildi < filtr.yaratildiGacha),
   );
 }
 
@@ -34,6 +40,12 @@
 export function kalitlar(
   saralash: readonly Saralash[],
 ): Saralash[] {
+  // Sukut — foydalanuvchi tartibi (frontend sudrab tartiblaydi)
+  if (saralash.length === 0)
+    return [
+      { maydon: "tartib", kamayish: false },
+      { maydon: "id", kamayish: false },
+    ];
   const k = saralash.filter((s) => s.maydon !== "id");
   const id = saralash.find((s) => s.maydon === "id");
   return [...k, id ?? { maydon: "id", kamayish: false }];

--- a/xotira-ombor.ts
+++ b/xotira-ombor.ts
@@ -18,6 +18,13 @@
   YozishNatijasi,
 } from "./ombor.ts";
 
+/** Ombor holatining nusxasi — fayl ombori shuni diskka yozadi */
+export type Surat = {
+  keyingiId: number;
+  versiya: number;
+  vazifalar: Vazifa[];
+};
+
 export class XotiraOmbori implements VazifaOmbori {
   readonly #vazifalar = new Map<number, Vazifa>();
   #keyingiId = 1;
@@ -25,8 +32,22 @@
   #versiya = 0;
   readonly #soat: () => Date;
 
-  constructor(soat: () => Date = () => new Date()) {
+  constructor(soat: () => Date = () => new Date(), surat?: Surat) {
     this.#soat = soat;
+    if (surat !== undefined) {
+      for (const v of surat.vazifalar)
+        this.#vazifalar.set(v.id, structuredClone(v));
+      this.#keyingiId = surat.keyingiId;
+      this.#versiya = surat.versiya;
+    }
+  }
+
+  surat(): Surat {
+    return {
+      keyingiId: this.#keyingiId,
+      versiya: this.#versiya,
+      vazifalar: structuredClone([...this.#vazifalar.values()]),
+    };
   }
 
   // structuredClone (sahifala ichida ham): chaqiruvchi qaytgan
@@ -58,6 +79,11 @@
       teglar: teglariniOl(yangi.matn),
       yaratildi: hozir,
       yangilandi: hozir,
+      tartib:
+        Math.max(
+          0,
+          ...[...this.#vazifalar.values()].map((t) => t.tartib),
+        ) + 1,
       versiya: 1,
     };
     this.#vazifalar.set(v.id, v);
@@ -119,7 +145,7 @@
     const ishlatildi = new Set<number>();
     const eski = this.#vazifalar;
     const yangi = new Map<number, Vazifa>();
-    for (const y of yangilar) {
+    for (const [i, y] of yangilar.entries()) {
       const id =
         y.id !== undefined && !ishlatildi.has(y.id)
           ? y.id
@@ -133,6 +159,7 @@
         teglar: teglariniOl(y.matn),
         yaratildi: avval?.yaratildi ?? hozir,
         yangilandi: hozir,
+        tartib: i + 1,
         versiya: (avval?.versiya ?? 0) + 1,
       });
     }

--- a/rest.test.ts
+++ b/rest.test.ts
@@ -208,6 +208,7 @@
     teglar: [],
     yaratildi: "2026-10-24T00:00:00.000Z",
     yangilandi: "2026-10-24T00:00:00.000Z",
+    tartib: id,
     versiya: 1,
   });
   const hammasi = [1, 2, 3, 4, 5].map(v);
@@ -217,7 +218,7 @@
     limit: 2,
     sahifa: { tur: "kursor" },
   });
-  assert.deepEqual(s1.keyingi, [2]);
+  // sukut kalitlari: tartib, id
+  assert.deepEqual(s1.keyingi, [2, 2]);
   const qolgan = hammasi.filter((x) => x.id !== 2);
   const s2 = sahifala(qolgan, {
     filtr: {},

// fayl-ombor.ts — VazifaOmbori JSON faylda: o'qish xotiradan
// (XotiraOmbori), har yozuvdan keyin butun holat diskka ATOMIK
// yoziladi
// (vaqtinchalik fayl + rename — 24-qism #17: oddiy yozish 17/20
// buzildi, temp+rename 0/20). Bitta jarayon uchun; ko'p jarayon —
// Postgres (26-qism)
import {
  mkdir,
  readFile,
  rename,
  rm,
  writeFile,
} from "node:fs/promises";
import { dirname } from "node:path";
import { XotiraOmbori } from "./xotira-ombor.ts";
import type { Surat } from "./xotira-ombor.ts";
import type {
  AlmashtirishVazifasi,
  Filtr,
  RoyxatNatija,
  RoyxatSorovi,
  Shart,
  TegSoni,
  VazifaOmbori,
  YozishNatijasi,
} from "./ombor.ts";
import type {
  Vazifa,
  VazifaOzgarishi,
  YangiVazifa,
} from "./vazifa.ts";

function suratmi(x: unknown): x is Surat {
  return (
    typeof x === "object" &&
    x !== null &&
    "keyingiId" in x &&
    "versiya" in x &&
    "vazifalar" in x &&
    Array.isArray(x.vazifalar)
  );
}

export class FaylOmbori implements VazifaOmbori {
  readonly #xotira: XotiraOmbori;
  readonly #yol: string;
  /**
   * yozuvlar navbati: ikki yozish bir vaqtda rename qilmasin
   * (Windows'da EPERM)
   */
  #navbat: Promise<void> = Promise.resolve();

  private constructor(yol: string, xotira: XotiraOmbori) {
    this.#yol = yol;
    this.#xotira = xotira;
  }

  /**
   * Fayl yo'q bo'lsa — bo'sh ombor; buzilgan bo'lsa — XATO (jim
   * yo'qotmaymiz: ma'lumot o'chib ketmasin)
   */
  static async och(
    yol: string,
    soat: () => Date = () => new Date(),
  ): Promise<FaylOmbori> {
    let matn: string | undefined;
    try {
      matn = await readFile(yol, "utf8");
    } catch (x) {
      if (
        !(x instanceof Error && "code" in x && x.code === "ENOENT")
      )
        throw x;
    }
    if (matn === undefined)
      return new FaylOmbori(yol, new XotiraOmbori(soat));
    const malumot: unknown = JSON.parse(matn);
    if (!suratmi(malumot))
      throw new Error(
        `${yol}: vazifalar fayli tuzilmasi noto'g'ri`,
      );
    return new FaylOmbori(yol, new XotiraOmbori(soat, malumot));
  }

  #saqla(): Promise<void> {
    const surat = this.#xotira.surat();
    const vaqtinchalik = `${this.#yol}.${String(process.pid)}.tmp`;
    this.#navbat = this.#navbat.then(async () => {
      await mkdir(dirname(this.#yol), { recursive: true });
      try {
        await writeFile(vaqtinchalik, JSON.stringify(surat), {
          mode: 0o600,
        });
        await rename(vaqtinchalik, this.#yol);
      } catch (x) {
        await rm(vaqtinchalik, { force: true });
        throw x;
      }
    });
    return this.#navbat;
  }

  async #yoz<T>(amal: Promise<T>): Promise<T> {
    const natija = await amal;
    // diskka yozilmaguncha javob qaytmaydi — "saqlandi" degan javob
    // yolg'on bo'lmasin
    await this.#saqla();
    return natija;
  }

  royxat(sorov: RoyxatSorovi): Promise<RoyxatNatija> {
    return this.#xotira.royxat(sorov);
  }
  soni(filtr: Filtr): Promise<number> {
    return this.#xotira.soni(filtr);
  }
  ol(id: number): Promise<Vazifa | undefined> {
    return this.#xotira.ol(id);
  }
  teglar(): Promise<TegSoni[]> {
    return this.#xotira.teglar();
  }
  yarat(yangi: YangiVazifa): Promise<Vazifa> {
    return this.#yoz(this.#xotira.yarat(yangi));
  }
  yangila(
    id: number,
    ozgarish: VazifaOzgarishi,
    shart?: Shart,
  ): Promise<YozishNatijasi<Vazifa>> {
    return this.#yoz(this.#xotira.yangila(id, ozgarish, shart));
  }
  ochir(id: number, shart?: Shart): Promise<YozishNatijasi<null>> {
    return this.#yoz(this.#xotira.ochir(id, shart));
  }
  almashtirHammasi(
    vazifalar: readonly AlmashtirishVazifasi[],
  ): Promise<{ vazifalar: Vazifa[]; versiya: number }> {
    return this.#yoz(this.#xotira.almashtirHammasi(vazifalar));
  }
}

// ombor-shartnoma.ts — VazifaOmbori SHARTNOMA testlari: har amalga
// oshirish (xotira, fayl, 26-qismda postgres) bir xil testdan o'tadi.
// Foydalanish: omborShartnomasi("postgres", async () => new
// PgOmbori(pool)) — har chaqiruv BO'SH ombor qaytarishi kerak
import { describe, test } from "node:test";
import assert from "node:assert/strict";
import type {
  RoyxatSorovi,
  VazifaOmbori,
} from "../src/vazifalar/ombor.ts";

export function omborShartnomasi(
  nom: string,
  yarat: () => Promise<VazifaOmbori>,
): void {
  describe(`VazifaOmbori shartnomasi: ${nom}`, () => {
    test("yarat: id 1 dan, teglar matndan, versiya 1, tartib oxiriga, sanalar ISO UTC; ol — nusxa", async () => {
      const o = await yarat();
      const v = await o.yarat({ matn: "Non olish #Uy #uy" });
      assert.equal(v.id, 1);
      assert.deepEqual(v.teglar, ["uy"]);
      assert.equal(v.versiya, 1);
      assert.equal(v.bajarildi, false);
      assert.equal(v.tartib, 1);
      assert.equal((await o.yarat({ matn: "ikkinchi" })).tartib, 2);
      assert.match(
        v.yaratildi,
        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
      );
      const olingan = await o.ol(1);
      assert.deepEqual(olingan, v);
      assert.ok(olingan);
      olingan.matn = "buzildi";
      assert.equal((await o.ol(1))?.matn, "Non olish #Uy #uy"); // ombordagi nusxa o'zgarmaydi
      assert.equal(await o.ol(99), undefined);
    });

    test("yangila: versiya +1, shart mos kelmasa konflikt, yo'q id — topilmadi", async () => {
      const o = await yarat();
      await o.yarat({ matn: "a" });
      const n = await o.yangila(
        1,
        { bajarildi: true },
        { versiya: 1 },
      );
      assert.ok(n.tur === "ok" && n.qiymat.versiya === 2);
      const k = await o.yangila(
        1,
        { matn: "b #yangi" },
        { versiya: 1 },
      );
      assert.ok(k.tur === "konflikt" && k.joriy.versiya === 2);
      const t = await o.yangila(1, { matn: "b #yangi" });
      assert.ok(
        t.tur === "ok" &&
          t.qiymat.teglar[0] === "yangi" &&
          t.qiymat.versiya === 3,
      );
      assert.equal(
        (await o.yangila(99, { bajarildi: true })).tur,
        "topilmadi",
      );
    });

    test("ochir: shart, topilmadi, to'plam versiyasi har yozuvda oshadi", async () => {
      const o = await yarat();
      await o.yarat({ matn: "a" });
      await o.yarat({ matn: "b" });
      const hammasi: RoyxatSorovi = {
        filtr: {},
        saralash: [],
        limit: 10,
        sahifa: { tur: "kursor" },
      };
      const v0 = (await o.royxat(hammasi)).versiya;
      assert.equal(
        (await o.ochir(1, { versiya: 5 })).tur,
        "konflikt",
      );
      assert.equal((await o.ochir(1)).tur, "ok");
      assert.equal((await o.ochir(1)).tur, "topilmadi");
      const r = await o.royxat(hammasi);
      assert.deepEqual(
        r.vazifalar.map((v) => v.id),
        [2],
      );
      assert.ok(r.versiya > v0);
    });

    test("royxat: filtr (bajarildi, teglar AND, qidiruv), saralash, offset, kursor, jami; soni; teglar", async () => {
      const o = await yarat();
      for (const [m, b] of [
        ["Non #uy", false],
        ["Hisobot #ish", true],
        ["Sut #uy #bozor", false],
        ["Olma #bozor", true],
      ] as const)
        await o.yarat({ matn: m, bajarildi: b });
      const r = (s: Partial<RoyxatSorovi>) =>
        o.royxat({
          filtr: {},
          saralash: [],
          limit: 10,
          sahifa: { tur: "kursor" },
          ...s,
        });
      assert.deepEqual(
        (
          await r({ filtr: { teglar: ["uy", "bozor"] } })
        ).vazifalar.map((v) => v.id),
        [3],
      );
      assert.deepEqual(
        (
          await r({ filtr: { bajarildi: true, qidiruv: "OLMA" } })
        ).vazifalar.map((v) => v.id),
        [4],
      );
      assert.deepEqual(
        (
          await r({
            saralash: [{ maydon: "matn", kamayish: true }],
          })
        ).vazifalar.map((v) => v.matn),
        [
          "Sut #uy #bozor",
          "Olma #bozor",
          "Non #uy",
          "Hisobot #ish",
        ],
      );
      const p1 = await r({ limit: 3, jami: true });
      assert.equal(p1.jami, 4);
      assert.equal(p1.borKeyingi, true);
      const p2 = await r({
        limit: 3,
        sahifa: { tur: "kursor", keyin: p1.keyingi ?? [] },
      });
      assert.deepEqual(
        p2.vazifalar.map((v) => v.id),
        [4],
      );
      assert.equal(p2.borKeyingi, false);
      assert.deepEqual(
        (
          await r({
            limit: 2,
            sahifa: { tur: "offset", offset: 2 },
          })
        ).vazifalar.map((v) => v.id),
        [3, 4],
      );
      assert.equal(await o.soni({ teglar: ["bozor"] }), 2);
      assert.deepEqual((await o.teglar())[0], {
        teg: "bozor",
        soni: 2,
      });
    });

    test("almashtirHammasi: massiv tartibi = tartib (sukut saralash), id saqlanadi/beriladi, eski o'chadi", async () => {
      const o = await yarat();
      await o.yarat({ matn: "eski" });
      const n = await o.almashtirHammasi([
        { id: 10, matn: "a #x", bajarildi: true },
        { matn: "b", bajarildi: false },
        { id: 5, matn: "c", bajarildi: false },
      ]);
      assert.deepEqual(
        n.vazifalar.map((v) => [v.id, v.tartib]),
        [
          [10, 1],
          [11, 2],
          [5, 3],
        ],
      );
      const r = await o.royxat({
        filtr: {},
        saralash: [],
        limit: 10,
        sahifa: { tur: "kursor" },
      });
      assert.deepEqual(
        r.vazifalar.map((v) => v.id),
        [10, 11, 5],
      ); // sudrab tartiblash saqlanadi
      assert.equal(await o.ol(1), undefined);
      assert.equal((await o.yarat({ matn: "d" })).id, 12);
    });
  });
}

import { test } from "node:test";
import assert from "node:assert/strict";
import {
  mkdtemp,
  readdir,
  readFile,
  rm,
  writeFile,
} from "node:fs/promises";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { omborShartnomasi } from "./ombor-shartnoma.ts";
import { XotiraOmbori } from "../src/vazifalar/xotira-ombor.ts";
import { FaylOmbori } from "../src/vazifalar/fayl-ombor.ts";

const papkalar: string[] = [];
async function yangiPapka(): Promise<string> {
  const p = await mkdtemp(join(tmpdir(), "vazifalar-api-"));
  papkalar.push(p);
  return p;
}
test.after(async () => {
  for (const p of papkalar)
    await rm(p, { recursive: true, force: true });
});

omborShartnomasi("xotira", () =>
  Promise.resolve(new XotiraOmbori()),
);
omborShartnomasi("fayl", async () =>
  FaylOmbori.och(
    join(await yangiPapka(), "ichki", "vazifalar.json"),
  ),
);

test("FaylOmbori: qayta ochilganda ma'lumot va id hisobi saqlangan; .tmp qolmaydi", async () => {
  const fayl = join(await yangiPapka(), "v.json");
  const a = await FaylOmbori.och(fayl);
  await a.yarat({ matn: "Non #uy" });
  await a.yarat({ matn: "Sut" });
  await a.ochir(2);
  const b = await FaylOmbori.och(fayl);
  assert.equal((await b.ol(1))?.matn, "Non #uy");
  // 2 qayta berilmaydi
  assert.equal((await b.yarat({ matn: "Yangi" })).id, 3);
  assert.deepEqual(
    (await readdir(dirname(fayl))).filter((f) =>
      f.endsWith(".tmp"),
    ),
    [],
  );
  assert.equal(
    (
      JSON.parse(await readFile(fayl, "utf8")) as {
        vazifalar: unknown[];
      }
    ).vazifalar.length,
    2,
  );
});

test("FaylOmbori: buzilgan fayl — xato (jim bo'sh ro'yxat EMAS)", async () => {
  const fayl = join(await yangiPapka(), "buzuq.json");
  await writeFile(fayl, '{"vazifalar": [');
  await assert.rejects(FaylOmbori.och(fayl), SyntaxError);
  await writeFile(fayl, '{"boshqa": 1}');
  await assert.rejects(FaylOmbori.och(fayl), /tuzilmasi noto'g'ri/);
});

test("FaylOmbori: parallel 50 yozuv — hammasi saqlanadi (yozish navbati)", async () => {
  const fayl = join(await yangiPapka(), "parallel.json");
  const a = await FaylOmbori.och(fayl);
  await Promise.all(
    Array.from({ length: 50 }, (_, i) =>
      a.yarat({ matn: `v${String(i)}` }),
    ),
  );
  const b = await FaylOmbori.och(fayl);
  assert.equal(await b.soni({}), 50);
});