Feature flag'lar backend'da: foizli rollout, segmentlar va kill switch

async function chelak(kalit, id) {
  const b = new TextEncoder().encode(`${kalit}:${id}`);
  const h = await crypto.subtle.digest("SHA-256", b);
  return new DataView(h).getUint32(0) % 100;
}

function baholash(b, kim, ch) {
  if (b === undefined) return true; // jadvalda yo'q — cheklanmagan
  if (!b.yoqilgan) return false; // kill switch
  if (b.foydalanuvchilar.includes(kim.id)) return true;
  if (kim.rol !== undefined && b.rollar.includes(kim.rol)) {
    return true;
  }
  return ch < b.foiz;
}

const b = { kalit: "ai-qadamlar", yoqilgan: true, foiz: 30,
  rollar: ["admin"], foydalanuvchilar: [7] };
for (const id of [1, 2, 3, 7]) {
  const ch = await chelak(b.kalit, id);
  console.log(`id ${id}: chelak ${ch} → ${baholash(b, { id }, ch)}`);
}

const idlar = Array.from({ length: 10_000 }, (_, i) => i + 1);
const chelaklar = await Promise.all(
  idlar.map((id) => chelak(b.kalit, id)));
const yoqiq = (foiz) => idlar.filter((_, i) => chelaklar[i] < foiz);
const y30 = yoqiq(30);
const y50 = new Set(yoqiq(50));
console.log("30 %:", y30.length, "| 50 %:", y50.size);
console.log("30 dagilar 50 da ham:", y30.every((id) => y50.has(id)));

const boshqa = await Promise.all(
  idlar.map((id) => chelak("yangi-dizayn", id)));
const ikkalasi = idlar.filter((_, i) =>
  chelaklar[i] < 10 && boshqa[i] < 10).length;
console.log("ikki bayroqning 10 % i ustma-ust:", ikkalasi);

id 1: chelak 44 → false
id 2: chelak 84 → false
id 3: chelak 8 → true
id 7: chelak 87 → true
30 %: 2983 | 50 %: 4994
30 dagilar 50 da ham: true
ikki bayroqning 10 % i ustma-ust: 101

SELECT id, ('x' || left(encode(sha256(convert_to(
  'ai-qadamlar:' || id, 'UTF8')), 'hex'), 8))::bit(32)::bigint % 100
  AS chelak
FROM generate_series(1, 3) id;

 id | chelak
----+--------
  1 |     44
  2 |     84
  3 |      8
(3 rows)

-- 306-bayroqlar.sql — feature flag'lar: kodni chiqarish (deploy) va
-- xususiyatni yoqish ALOHIDA. Baholash ilovada (bayroqlar.ts):
-- yoqilgan=false — hammaga o'chiq (kill switch); foydalanuvchilar
-- ro'yxatida — yoqiq; rollar segmentida — yoqiq; aks holda foizli
-- rollout: sha256(kalit:foydalanuvchi_id) → 0..99 < foiz
-- (deterministik; foiz oshsa — eski "yoqiq"lar qoladi).
CREATE TABLE bayroqlar (
  kalit            text        NOT NULL,
  yoqilgan         boolean     NOT NULL DEFAULT false,
  foiz             smallint    NOT NULL DEFAULT 0,
  rollar           text[]      NOT NULL DEFAULT '{}',
  foydalanuvchilar bigint[]    NOT NULL DEFAULT '{}',
  tavsif           text,
  yangilangan_vaqt timestamptz NOT NULL DEFAULT now(),
  CONSTRAINT bayroqlar_pkey PRIMARY KEY (kalit),
  CONSTRAINT bayroqlar_kalit_check
    CHECK (kalit ~ '^[a-z][a-z0-9-]{1,49}$'),
  CONSTRAINT bayroqlar_foiz_check CHECK (foiz BETWEEN 0 AND 100)
);
-- boshlang'ich bayroqlar: AI xususiyatlari yoqiq (100 %); rollout —
-- admin yo'li bilan (PUT /v1/admin/bayroqlar/:kalit)
INSERT INTO bayroqlar (kalit, yoqilgan, foiz, rollar, tavsif) VALUES
  ('ai-qadamlar', true, 100, '{}', 'POST /v1/vazifalar/:id/qadamlar'),
  ('ai-yordamchi', true, 100, '{}',
   'GET /v1/qidiruv, POST /v1/yordamchi/savol');

GRANT SELECT ON bayroqlar TO vazifalar_ilova;
-- admin yo'li (auth pool)
GRANT SELECT, INSERT, UPDATE ON bayroqlar TO vazifalar_auth;

COMMENT ON TABLE bayroqlar IS
  'feature flag''lar — kill switch, ruxsat ro''yxati, rol segmenti, '
  'deterministik foizli rollout';

CREATE TABLE
INSERT 0 2
GRANT
GRANT
COMMENT

\set VERBOSITY terse
UPDATE bayroqlar SET foiz = 101 WHERE kalit = 'ai-qadamlar';
SELECT kalit, yoqilgan, foiz FROM bayroqlar ORDER BY kalit;

ERROR:  new row for relation "bayroqlar" violates check constraint "bayroqlar_foiz_check"
    kalit     | yoqilgan | foiz
--------------+----------+------
 ai-qadamlar  | t        |  100
 ai-yordamchi | t        |  100
(2 rows)

/// feature flag'lar (sql/306). Ilova SQL bilan o'qiydi,
/// Prisma modeli — sxema drift tekshiruvi uchun
model Bayroq {
  kalit            String   @id
  yoqilgan         Boolean  @default(false)
  foiz             Int      @default(0) @db.SmallInt
  rollar           String[] @default([])
  foydalanuvchilar BigInt[] @default([])
  tavsif           String?
  yangilanganVaqt  DateTime @default(now())
    @map("yangilangan_vaqt") @db.Timestamptz(6)

  @@map("bayroqlar")
}

// bayroqlar.ts — feature flag'lar (sql/306). Baholash ilovada,
// bayroqlar jadvali jarayon xotirasida 30 s keshlanadi (har so'rovda
// DB emas). Kesh oqibati: admin o'zgartirgani boshqa nusxalarda
// (instance) 30 s gacha kechikadi — o'zgartirgan nusxada darhol
// (tozala()). Ko'p nusxada darhol kerak bo'lsa — Redis Pub/Sub yoki
// LISTEN/NOTIFY (darsda). OpenFeature/Unleash/GrowthBook —
// sinalmagan.
import {
  Body, Controller, Get, Global, HttpCode, Inject, Module, Param, Put,
  Req,
} from "@nestjs/common";
import type { DynamicModule, Provider, Type } from "@nestjs/common";
import { createHash } from "node:crypto";
import type { Request } from "express";
import type { Pool } from "pg";
import { z } from "zod";
import { AUTH, BAYROQLAR } from "../tokenlar.ts";
import type { AuthBogliqliklari } from "../auth/xizmat.ts";
import { Rollar } from "../auth/qoriqchi.ts";
import { JsonTana } from "../umumiy/json-tana.guard.ts";
import { TopilmadiXatosi } from "../umumiy/xatolar.ts";
import { Audit } from "../audit/audit.ts";

export type Bayroq = {
  kalit: string; yoqilgan: boolean; foiz: number;
  rollar: string[]; foydalanuvchilar: number[];
};
export type Kim = { id: number; rol?: string | undefined };

/** 0..99 — kalit va foydalanuvchi bo'yicha deterministik (bir
 * bayroqdagi 10 % boshqa bayroqdagi 10 % bilan bir xil odamlar
 * emas — kalit qo'shilgan) */
export function chelak(kalit: string, id: number): number {
  return createHash("sha256").update(`${kalit}:${String(id)}`)
    .digest().readUInt32BE(0) % 100;
}

export function baholash(b: Bayroq | undefined, kim: Kim): boolean {
  // jadvalda yo'q bayroq — xususiyat cheklanmagan
  if (b === undefined) return true;
  // kill switch — hammaga, ruxsat ro'yxatiga ham
  if (!b.yoqilgan) return false;
  if (b.foydalanuvchilar.includes(kim.id)) return true;
  if (kim.rol !== undefined && b.rollar.includes(kim.rol)) {
    return true;
  }
  return chelak(b.kalit, kim.id) < b.foiz;
}

export class BayroqlarXizmati {
  #kesh: { vaqt: number; bayroqlar: Map<string, Bayroq> } | undefined;
  constructor(
    private readonly pool: Pool, private readonly ttlMs = 30_000,
  ) {}

  async hammasi(): Promise<Map<string, Bayroq>> {
    if (this.#kesh !== undefined
      && Date.now() - this.#kesh.vaqt < this.ttlMs) {
      return this.#kesh.bayroqlar;
    }
    const { rows } = await this.pool.query<{
      kalit: string; yoqilgan: boolean; foiz: number;
      rollar: string[]; foydalanuvchilar: string[];
    }>("SELECT kalit, yoqilgan, foiz, rollar, "
      + "foydalanuvchilar::text[] AS foydalanuvchilar "
      + "FROM bayroqlar");
    const bayroqlar = new Map(rows.map((r) => [r.kalit, {
      ...r, foydalanuvchilar: r.foydalanuvchilar.map(Number),
    }]));
    this.#kesh = { vaqt: Date.now(), bayroqlar };
    return bayroqlar;
  }

  async yoqilganmi(kalit: string, kim: Kim): Promise<boolean> {
    return baholash((await this.hammasi()).get(kalit), kim);
  }

  tozala(): void {
    this.#kesh = undefined;
  }
}

/** so'rovdan baholash uchun kim (sessiya bo'lsa rol bilan; API
 * kalit — rolsiz: faqat foiz va ruxsat ro'yxati) */
export function kimOl(req: Request): Kim | undefined {
  return req.egasi === undefined
    ? undefined
    : { id: req.egasi, rol: req.sessiya?.rol };
}

/** xususiyat yoqilmagan bo'lsa — 404 (xususiyat mavjudligini
 * oshkor qilmaymiz) */
export async function bayroqKerak(
  b: BayroqlarXizmati | null, kalit: string, req: Request,
): Promise<void> {
  const kim = kimOl(req);
  if (b === null || kim === undefined) return;
  if (!(await b.yoqilganmi(kalit, kim))) {
    throw new TopilmadiXatosi(
      `${req.method} ${req.path} — bunday manzil yo'q`,
      "xususiyat-yoq", "Topilmadi");
  }
}

/** GET /v1/bayroqlar — joriy foydalanuvchi uchun baholangan
 * bayroqlar (frontend UI'ni shunga qarab ko'rsatadi; qoidalar
 * oshkor qilinmaydi) */
@Controller("bayroqlar")
export class BayroqlarController {
  constructor(
    @Inject(BAYROQLAR) private readonly b: BayroqlarXizmati,
  ) {}

  @Get()
  async royxat(
    @Req() req: Request,
  ): Promise<Record<string, boolean>> {
    const kim = kimOl(req);
    const hammasi = await this.b.hammasi();
    return Object.fromEntries([...hammasi.values()].map((x) =>
      [x.kalit, kim === undefined ? false : baholash(x, kim)]));
  }
}

const BayroqSxemasi = z.strictObject({
  yoqilgan: z.boolean(),
  foiz: z.int().min(0).max(100),
  rollar: z.array(z.enum(["foydalanuvchi", "admin"])).max(2)
    .default([]),
  foydalanuvchilar: z.array(z.int().positive()).max(1000)
    .default([]),
  tavsif: z.string().max(200).optional(),
});
const Kalit = z.strictObject({
  kalit: z.string().regex(/^[a-z][a-z0-9-]{1,49}$/),
});

@Controller("admin/bayroqlar")
@Rollar("admin")
export class AdminBayroqlarController {
  constructor(
    @Inject(BAYROQLAR) private readonly b: BayroqlarXizmati,
    @Inject(AUTH) private readonly auth: AuthBogliqliklari,
  ) {}

  @Get()
  async royxat(): Promise<Bayroq[]> {
    return [...(await this.b.hammasi()).values()];
  }

  /** yaratish yoki o'zgartirish (upsert) — auditga yoziladi, shu
   * nusxaning keshi darhol tozalanadi */
  @Put(":kalit")
  @HttpCode(200)
  @JsonTana()
  @Audit("bayroq.ozgartirildi", "bayroq")
  async yoz(
    @Param({ schema: Kalit }) { kalit }: { kalit: string },
    @Body({ schema: BayroqSxemasi })
    x: z.output<typeof BayroqSxemasi>,
  ): Promise<Bayroq> {
    await this.auth.pool.query(
      `INSERT INTO bayroqlar (kalit, yoqilgan, foiz, rollar,
         foydalanuvchilar, tavsif, yangilangan_vaqt)
       VALUES ($1, $2, $3, $4, $5, $6, now())
       ON CONFLICT (kalit) DO UPDATE SET yoqilgan = $2, foiz = $3,
         rollar = $4, foydalanuvchilar = $5,
         tavsif = coalesce($6, bayroqlar.tavsif),
         yangilangan_vaqt = now()`,
      [kalit, x.yoqilgan, x.foiz, x.rollar, x.foydalanuvchilar,
        x.tavsif ?? null]);
    this.b.tozala();
    return {
      kalit, yoqilgan: x.yoqilgan, foiz: x.foiz, rollar: x.rollar,
      foydalanuvchilar: x.foydalanuvchilar,
    };
  }
}

@Global()
@Module({})
export class BayroqlarModule {
  /** auth yoqilgan bo'lsa (postgres/prisma) — bayroqlar auth
   * pool'idan o'qiladi; aks holda null (cheklovsiz) */
  static forRoot(yoqilgan: boolean): DynamicModule {
    const controllers: Type[] = yoqilgan
      ? [BayroqlarController, AdminBayroqlarController]
      : [];
    const providers: Provider[] = [{
      provide: BAYROQLAR, inject: [AUTH],
      useFactory: (
        a: AuthBogliqliklari | null,
      ): BayroqlarXizmati | null =>
        (yoqilgan && a !== null
          ? new BayroqlarXizmati(a.pool)
          : null),
    }];
    return {
      module: BayroqlarModule, controllers, providers,
      exports: [BAYROQLAR],
    };
  }
}

/** BayroqlarXizmati yoki null (auth yo'q — cheklovsiz) */
export const BAYROQLAR = Symbol("BAYROQLAR");

import { BayroqlarModule } from "./bayroq/bayroqlar.ts";

// imports: [ ...
  // feature flag'lar (auth bilan)
  BayroqlarModule.forRoot(authYoqilgan),
// ... ]

import { AI, BAYROQLAR } from "../tokenlar.ts";
import { bayroqKerak } from "../bayroq/bayroqlar.ts";
import type { BayroqlarXizmati } from "../bayroq/bayroqlar.ts";

// AiVazifaController, QidiruvController, YordamchiController:
constructor(
  @Inject(AI) private readonly ai: AiXizmatlari,
  @Inject(BAYROQLAR)
  private readonly bayroqlar: BayroqlarXizmati | null,
) {}

// POST /v1/vazifalar/:id/qadamlar — birinchi qator:
await bayroqKerak(this.bayroqlar, "ai-qadamlar", req);
// GET /v1/qidiruv va POST /v1/yordamchi/savol — birinchi qator:
await bayroqKerak(this.bayroqlar, "ai-yordamchi", req);

    // 31: rol ham (30-qism ochiq xatosi — frontend admin menyusini
    // ko'rsatishi uchun; avval /v1/admin/* ga urinib 403 olish
    // kerak edi)
    return {
      foydalanuvchi: { ...s.foydalanuvchi, rol: s.rol },
      sessiya: {
        id: s.id, eslabQol: s.eslabQol,
        yaratilgan: s.yaratilgan.toISOString(),
        tugash: s.tugash.toISOString(),
      },
    };

- { id: 1, email: "aziz@example.com", toliqIsm: "Aziz Google" }
+ { id: 1, email: "aziz@example.com", toliqIsm: "Aziz Google",
+   rol: "foydalanuvchi" }

import { afterAll, beforeEach, describe, test } from "vitest";
import { baholash, chelak } from "../src/bayroq/bayroqlar.ts";

describe("#25 bayroqni baholash (toza funksiya)", () => {
  const b = {
    kalit: "yangi-xususiyat", yoqilgan: true, foiz: 30,
    rollar: ["admin"], foydalanuvchilar: [7],
  };
  test("kill switch > ruxsat ro'yxati > rol > foiz; jadvalda yo'q — "
    + "cheklanmagan; deterministik", () => {
    assert.equal(
      baholash({ ...b, yoqilgan: false }, { id: 7, rol: "admin" }),
      false);
    assert.equal(baholash({ ...b, foiz: 0 }, { id: 7 }), true);
    assert.equal(
      baholash({ ...b, foiz: 0 }, { id: 8, rol: "admin" }), true);
    assert.equal(baholash(undefined, { id: 1 }), true);
    assert.equal(chelak("a", 42), chelak("a", 42));
  });
  test("foizli rollout: 10 000 da 30 % → 28–32 %; 30 → 50 % da "
    + "avvalgi yoqilganlarning HAMMASI yoqiq qoladi", () => {
    const ids = Array.from({ length: 10_000 }, (_, i) => i + 1);
    const oddiy = { ...b, rollar: [], foydalanuvchilar: [] };
    const y30 = ids.filter((id) => baholash(oddiy, { id }));
    const y50 = new Set(ids.filter((id) =>
      baholash({ ...oddiy, foiz: 50 }, { id })));
    assert.ok(y30.length >= 2800 && y30.length <= 3200,
      `30 %: ${String(y30.length)}`);
    assert.ok(y30.every((id) => y50.has(id)));
  });
});

    // tozala() public jadvallarni TRUNCATE qiladi — 306 dagi
    // boshlang'ich bayroqlar ham ketadi; qayta qo'yamiz
    await pool.query("INSERT INTO bayroqlar (kalit, yoqilgan, foiz) "
      + "VALUES ('ai-qadamlar', true, 100), "
      + "('ai-yordamchi', true, 100)");

  test("#25 bayroqlar: o'chirilsa AI yo'li 404, ruxsat ro'yxati "
    + "bilan ochiq; kill switch ustun; PUT 403/422; audit",
  async () => {
    const { app, admin, aziz, azizId } = await tayyorla();
    const B = "/v1/admin/bayroqlar/ai-qadamlar";
    const bayroqlar = async () => (await request(app)
      .get("/v1/bayroqlar").set("Cookie", aziz).expect(200))
      .body as Record<string, boolean>;
    assert.deepEqual(await bayroqlar(),
      { "ai-qadamlar": true, "ai-yordamchi": true });
    const v = (await request(app).post("/v1/vazifalar")
      .set("Cookie", aziz).send({ matn: "Bayroq sinovi" })
      .expect(201)).body as { id: number };
    const Q = `/v1/vazifalar/${String(v.id)}/qadamlar`;
    await request(app).post(Q).set("Cookie", aziz).expect(200);
    await request(app).put(B).set("Cookie", aziz)
      .send({ yoqilgan: false, foiz: 0 }).expect(403);
    await request(app).put(B).set("Cookie", admin)
      .send({ yoqilgan: true, foiz: 101 }).expect(422);
    await request(app).put(B).set("Cookie", admin)
      .send({ yoqilgan: true, foiz: 0 }).expect(200);
    const r = await request(app).post(Q).set("Cookie", aziz)
      .expect(404);
    assert.match((r.body as { type: string }).type, /xususiyat-yoq$/);
    assert.equal((await bayroqlar())["ai-qadamlar"], false);
    await request(app).put(B).set("Cookie", admin)
      .send({ yoqilgan: true, foiz: 0, foydalanuvchilar: [azizId] })
      .expect(200);
    await request(app).post(Q).set("Cookie", aziz).expect(200);
    await request(app).put(B).set("Cookie", admin)
      .send({
        yoqilgan: false, foiz: 100, foydalanuvchilar: [azizId],
      })
      .expect(200);
    // kill switch ro'yxatdan ustun
    await request(app).post(Q).set("Cookie", aziz).expect(404);
    const j = (await jurnal()).filter((x) =>
      x.amal === "bayroq.ozgartirildi"
      && x.obyekt_id === "ai-qadamlar");
    assert.equal(j.length, 3);
  });

  test("ochiq xato (30-qism): GET /v1/auth/men javobida rol bor",
  async () => {
    const { app, admin, aziz } = await tayyorla();
    const rol = async (cookie: string) => ((await request(app)
      .get("/v1/auth/men").set("Cookie", cookie)
      .expect(200)).body as {
      foydalanuvchi: { rol: string };
    }).foydalanuvchi.rol;
    assert.equal(await rol(admin), "admin");
    assert.equal(await rol(aziz), "foydalanuvchi");
  });

 ✓ |asosiy| test/prodakshn.test.ts (6 tests) 3679ms
   ✓ #25 bayroqni baholash (toza funksiya) (2)
     ✓ foizli rollout: 10 000 da 30 % → 28–32 %; 30 → 50 % da avvalgi yoqilganlarning HAMMASI yoqiq qoladi 340ms
   ✓ #23 audit: muvaffaqiyatli amal yoziladi, 403 — yo'q; zanjir butun → buzilsa topiladi 1503ms
   ✓ #23 audit: hisob o'chirish — aktyor o'zi (amaldan keyin sessiya yo'q bo'lsa ham) 546ms
   ✓ #25 bayroqlar: o'chirilsa AI yo'li 404, ruxsat ro'yxati bilan ochiq; kill switch ustun; PUT 403/422; audit 551ms
   ✓ ochiq xato (30-qism): GET /v1/auth/men javobida rol bor 447ms
 ...
 Test Files  3 passed (3)
      Tests  21 passed (21)

| `GET /v1/bayroqlar` | joriy foydalanuvchi uchun baholangan feature flag'lar `{ "ai-qadamlar": true, … }` (qoidalar oshkor qilinmaydi) | 200 |
| `GET/PUT /v1/admin/bayroqlar[/:kalit]` (admin) | bayroqlar: `{ yoqilgan, foiz 0–100, rollar, foydalanuvchilar, tavsif }` — o'chiq xususiyat yo'li 404 `xususiyat-yoq` | 200 / 403 / 422 |
| `GET /v1/admin/audit?keyin=&limit=` (admin) | audit jurnali (faqat qo'shiladi, hash zanjiri) | 200 `{ yozuvlar, keyingi }` |
| `POST /v1/admin/audit/tekshir` (admin) | zanjir butunligi | 200 `{ butun, yozuvlar, buzilganlar: [{ id, sabab }] }` |

git add -A
M='feat: audit jurnali (faqat qo'"'"'shiladi, hash zanjiri, @Audit '
M+='interceptor), feature flag'"'"'lar (foizli rollout, segment, '
M+='kill switch); /auth/men da rol'
git commit -m "$M"