Audit log: kim, qachon, nimani — o'zgarmas jurnal va hash zanjiri

const hex = (b) => [...new Uint8Array(b)]
  .map((x) => x.toString(16).padStart(2, "0")).join("");
async function sha256(matn) {
  const b = new TextEncoder().encode(matn);
  return hex(await crypto.subtle.digest("SHA-256", b));
}
const satr = (y) => [y.id, y.aktyor, y.amal, y.obyektId].join("|");

async function yoz(jurnal, aktyor, amal, obyektId) {
  const oldingi = jurnal.at(-1)?.hash ?? "";
  const id = jurnal.length + 1;
  const y = { id, aktyor, amal, obyektId, oldingi };
  y.hash = await sha256(oldingi + satr(y));
  jurnal.push(y);
}

async function tekshir(jurnal) {
  const buzilgan = [];
  for (let i = 0; i < jurnal.length; i++) {
    const y = jurnal[i];
    const kutilgan = i === 0 ? "" : jurnal[i - 1].hash;
    if (y.oldingi !== kutilgan) {
      buzilgan.push(`${y.id}: zanjir uzilgan`);
    } else if (y.hash !== await sha256(y.oldingi + satr(y))) {
      buzilgan.push(`${y.id}: yozuv o'zgartirilgan`);
    }
  }
  return buzilgan.length === 0 ? "butun" : buzilgan.join("; ");
}

const jurnal = [];
await yoz(jurnal, 1, "admin.bloklash", "2");
await yoz(jurnal, 1, "api_kalit.yaratildi", null);
await yoz(jurnal, 1, "bayroq.ozgartirildi", "ai-qadamlar");
console.log("hash boshi:", jurnal[0].hash.slice(0, 16));
console.log("1)", await tekshir(jurnal));
jurnal[0].aktyor = 7; // kimdir aktyorni almashtirdi
console.log("2)", await tekshir(jurnal));
jurnal[0].aktyor = 1;
jurnal.splice(1, 1); // o'rtadagi yozuv o'chirildi
console.log("3)", await tekshir(jurnal));

hash boshi: a6794e32895d55fb
1) butun
2) 1: yozuv o'zgartirilgan
3) 3: zanjir uzilgan

-- 305-audit.sql — audit jurnali: KIM, QACHON, NIMANI (admin amallari,
-- hisob o'chirish, API kalitlar, bayroqlar).
-- vazifa_tarixi (010) — ma'lumot o'zgarishi; auth_hodisalar (111) —
-- xavfsizlik hodisalari (180 kun); audit — javobgarlik: o'zgarmas
-- va uzoq saqlanadi. O'zgarmaslik: (1) faqat qo'shiladi —
-- UPDATE/DELETE/TRUNCATE trigger bilan taqiqlangan (superuser ham —
-- trigger'ni ataylab o'chirmasa); (2) hash zanjiri: hash =
-- sha256(oldingi_hash || maydonlar) — trigger o'chirilib qator
-- o'zgartirilsa ham audit_tekshir() uzilgan joyni topadi.
-- Alohida sxema `audit`: Prisma (public) va testlardagi TRUNCATE
-- unga tegmaydi; ilova rollariga — faqat audit_yoz() funksiyasi.
CREATE SCHEMA audit;

CREATE TABLE audit.jurnal (
  id           bigint      GENERATED ALWAYS AS IDENTITY,
  vaqt         timestamptz NOT NULL,
  -- FK yo'q: aktyor hisobi o'chirilsa (302) ham yozuv qoladi
  aktyor_id    bigint,
  amal         text        NOT NULL,
  obyekt       text,
  obyekt_id    text,
  tafsilot     jsonb       NOT NULL DEFAULT '{}'::jsonb,
  sorov_id     text,
  oldingi_hash bytea,
  hash         bytea       NOT NULL,
  CONSTRAINT jurnal_pkey PRIMARY KEY (id),
  CONSTRAINT jurnal_amal_check
    CHECK (amal ~ '^[a-z][a-z0-9_.-]{1,59}$')
);
CREATE INDEX jurnal_aktyor_vaqt ON audit.jurnal (aktyor_id, vaqt);
CREATE INDEX jurnal_obyekt ON audit.jurnal (obyekt, obyekt_id);

-- hash qilinadigan kanonik satr (tekshiruv ham AYNAN shundan
-- foydalanadi)
CREATE FUNCTION audit.satr(j audit.jurnal) RETURNS bytea
LANGUAGE sql IMMUTABLE
RETURN convert_to(concat_ws('|', j.id,
  to_char(j.vaqt AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US'),
  j.aktyor_id, j.amal, j.obyekt, j.obyekt_id, j.tafsilot::text,
  j.sorov_id), 'UTF8');

CREATE FUNCTION audit_yoz(aktyor bigint, amal text, obyekt text,
  obyekt_id text, tafsilot jsonb, sorov_id text) RETURNS bigint
LANGUAGE plpgsql SECURITY DEFINER
SET search_path = pg_catalog, public, audit AS $$
DECLARE oldingi bytea; j audit.jurnal;
BEGIN
  -- zanjir tartibi: bir vaqtda ikki yozuv bir xil "oldingi"ni
  -- olmasin (tranzaksiya oxirigacha qulf)
  PERFORM pg_advisory_xact_lock(hashtext('audit.jurnal'));
  SELECT hash INTO oldingi FROM audit.jurnal ORDER BY id DESC LIMIT 1;
  j.id := nextval(pg_get_serial_sequence('audit.jurnal', 'id'));
  j.vaqt := date_trunc('microseconds', clock_timestamp());
  j.aktyor_id := aktyor; j.amal := amal; j.obyekt := obyekt;
  j.obyekt_id := obyekt_id; j.tafsilot := coalesce(tafsilot, '{}');
  j.sorov_id := sorov_id;
  j.oldingi_hash := oldingi;
  j.hash := sha256(coalesce(oldingi, '\x'::bytea) || audit.satr(j));
  INSERT INTO audit.jurnal OVERRIDING SYSTEM VALUE SELECT j.*;
  RETURN j.id;
END $$;

-- zanjirni tekshirish: buzilgan yozuvlar (bo'sh natija — butun)
CREATE FUNCTION audit_tekshir() RETURNS TABLE (id bigint, sabab text)
LANGUAGE sql STABLE SECURITY DEFINER
SET search_path = pg_catalog, public, audit AS $$
  SELECT x.id, x.sabab FROM (
    SELECT j.id,
      CASE
        WHEN j.oldingi_hash IS DISTINCT FROM
             lag(j.hash) OVER (ORDER BY j.id)
          THEN 'oldingi_hash zanjirga mos emas '
            || '(yozuv o''chirilgan yoki qo''shilgan)'
        WHEN j.hash <> sha256(coalesce(j.oldingi_hash, '\x'::bytea)
                              || audit.satr(j))
          THEN 'hash mos emas (yozuv o''zgartirilgan)'
      END AS sabab
    FROM audit.jurnal j) x
  WHERE x.sabab IS NOT NULL ORDER BY x.id
$$;

CREATE FUNCTION audit.ozgartirish_taqiq() RETURNS trigger
LANGUAGE plpgsql AS $$ BEGIN
  RAISE EXCEPTION 'audit.jurnal faqat qo''shiladi (%)', TG_OP
    USING ERRCODE = '42501';
END $$;
CREATE TRIGGER jurnal_ozgarmas BEFORE UPDATE OR DELETE ON audit.jurnal
  FOR EACH ROW EXECUTE FUNCTION audit.ozgartirish_taqiq();
CREATE TRIGGER jurnal_ozgarmas_truncate
  BEFORE TRUNCATE ON audit.jurnal
  FOR EACH STATEMENT EXECUTE FUNCTION audit.ozgartirish_taqiq();

REVOKE ALL ON SCHEMA audit FROM PUBLIC;
REVOKE EXECUTE ON FUNCTION
  audit_yoz(bigint, text, text, text, jsonb, text), audit_tekshir()
  FROM PUBLIC;
GRANT EXECUTE ON FUNCTION
  audit_yoz(bigint, text, text, text, jsonb, text)
  TO vazifalar_ilova, vazifalar_auth;
GRANT EXECUTE ON FUNCTION audit_tekshir() TO vazifalar_auth;
-- admin ro'yxati (GET /v1/admin/audit) — auth roli o'qiydi
GRANT USAGE ON SCHEMA audit TO vazifalar_auth;
GRANT SELECT ON audit.jurnal TO vazifalar_auth;

COMMENT ON TABLE audit.jurnal IS
  'audit jurnali — faqat qo''shiladi (trigger), '
  'hash zanjiri (audit_tekshir)';

CREATE SCHEMA
CREATE TABLE
CREATE INDEX
CREATE INDEX
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE TRIGGER
CREATE TRIGGER
REVOKE
REVOKE
GRANT
GRANT
GRANT
GRANT
COMMENT

SELECT audit_yoz(NULL, 'admin.bloklash', 'foydalanuvchi', '2',
  '{"metod":"POST"}', 's-1') AS id;
SELECT audit_yoz(1, 'api_kalit.yaratildi', 'api_kalit', NULL,
  '{}', 's-2') AS id;
SELECT audit_yoz(1, 'bayroq.ozgartirildi', 'bayroq', 'ai-qadamlar',
  '{}', 's-3') AS id;
SELECT id, amal, length(hash) AS hash_bayt,
       oldingi_hash IS NULL AS zanjir_boshi
FROM audit.jurnal ORDER BY id;
SELECT count(*) AS buzilgan FROM audit_tekshir();

 id
----
  1
(1 row)

 id
----
  2
(1 row)

 id
----
  3
(1 row)

 id |        amal         | hash_bayt | zanjir_boshi
----+---------------------+-----------+--------------
  1 | admin.bloklash      |        32 | t
  2 | api_kalit.yaratildi |        32 | f
  3 | bayroq.ozgartirildi |        32 | f
(3 rows)

 buzilgan
----------
        0
(1 row)

UPDATE audit.jurnal SET amal = 'yashirin.amal' WHERE id = 2;
TRUNCATE audit.jurnal;

ERROR:  audit.jurnal faqat qo'shiladi (UPDATE)
CONTEXT:  PL/pgSQL function audit.ozgartirish_taqiq() line 2 at RAISE
ERROR:  audit.jurnal faqat qo'shiladi (TRUNCATE)
CONTEXT:  PL/pgSQL function audit.ozgartirish_taqiq() line 2 at RAISE

ALTER TABLE audit.jurnal DISABLE TRIGGER jurnal_ozgarmas;
UPDATE audit.jurnal SET tafsilot = '{"metod":"GET"}' WHERE id = 1;
DELETE FROM audit.jurnal WHERE id = 2;
ALTER TABLE audit.jurnal ENABLE TRIGGER jurnal_ozgarmas;
SELECT * FROM audit_tekshir();

ALTER TABLE
UPDATE 1
DELETE 1
ALTER TABLE
 id |                               sabab
----+--------------------------------------------------------------------
  1 | hash mos emas (yozuv o'zgartirilgan)
  3 | oldingi_hash zanjirga mos emas (yozuv o'chirilgan yoki qo'shilgan)
(2 rows)

SET ROLE vazifalar_ilova;
SELECT audit_yoz(NULL, 'sinov.amal', NULL, NULL, '{}', NULL) > 0
  AS yozdi;
SELECT count(*) FROM audit.jurnal;

SET
 yozdi
-------
 t
(1 row)

ERROR:  permission denied for schema audit
LINE 1: SELECT count(*) FROM audit.jurnal;
                             ^

// audit.ts — audit jurnali Nest'da. `@Audit("amal", "obyekt")` —
// handler muvaffaqiyatli tugagach (2xx) global AuditInterceptor
// `audit_yoz()` ga yozadi (sql/305: faqat qo'shiladi, hash zanjiri).
// Aktyor — joriy foydalanuvchi (sessiya yoki API kalit), obyekt_id —
// `:id` parametri, sorov_id — correlation ID (25-qism).
// Muvaffaqiyatsiz so'rov (4xx/5xx) yozilmaydi — urinishlar
// `auth_hodisalar` da. Yozish amaldan KEYIN, alohida tranzaksiyada:
// amal bajarilib audit yozilmasa — error log. Qat'iy talab bo'lsa —
// amal bilan bitta tranzaksiyada (darsda).
import {
  Controller, Get, HttpCode, Inject, Injectable, Post, Query,
  SetMetadata,
} from "@nestjs/common";
import type {
  CallHandler, ExecutionContext, NestInterceptor,
} from "@nestjs/common";
import { Reflector } from "@nestjs/core";
import type { Request } from "express";
import { from, mergeMap, Observable } from "rxjs";
import { z } from "zod";
import { AUTH, LOG } from "../tokenlar.ts";
import type { AuthBogliqliklari } from "../auth/xizmat.ts";
import { Rollar } from "../auth/qoriqchi.ts";
import { joriyLog } from "../umumiy/log.ts";
import type { Log } from "../umumiy/log.ts";

const AUDIT = "audit:amal";
export type AuditBelgisi = { amal: string; obyekt?: string };
/** @Audit("admin.bloklash", "foydalanuvchi") — muvaffaqiyatli
 * bajarilsa audit jurnaliga */
export const Audit = (
  amal: string, obyekt?: string,
): MethodDecorator =>
  SetMetadata(AUDIT, {
    amal, ...(obyekt === undefined ? {} : { obyekt }),
  } satisfies AuditBelgisi);

export async function auditYoz(
  pool: AuthBogliqliklari["pool"],
  y: {
    aktyor: number | null; amal: string; obyekt?: string | null;
    obyektId?: string | null; tafsilot?: Record<string, unknown>;
    sorovId?: string | null;
  },
): Promise<number> {
  const { rows } = await pool.query<{ id: string }>(
    "SELECT audit_yoz($1, $2, $3, $4, $5, $6) AS id",
    [y.aktyor, y.amal, y.obyekt ?? null, y.obyektId ?? null,
      y.tafsilot ?? {}, y.sorovId ?? null]);
  return Number(rows[0]?.id);
}

@Injectable()
export class AuditInterceptor implements NestInterceptor {
  constructor(
    private readonly reflector: Reflector,
    @Inject(AUTH) private readonly auth: AuthBogliqliklari | null,
    @Inject(LOG) private readonly log: Log,
  ) {}

  intercept(k: ExecutionContext, keyingi: CallHandler):
    Observable<unknown> {
    const b = this.reflector.get<AuditBelgisi | undefined>(
      AUDIT, k.getHandler());
    if (b === undefined || this.auth === null
      || k.getType() !== "http") {
      return keyingi.handle();
    }
    const req = k.switchToHttp().getRequest<Request>();
    const pool = this.auth.pool;
    // aktyor so'rov BOSHIDA olinadi: DELETE /v1/auth/men dan keyin
    // sessiya yo'q bo'ladi
    const aktyor = req.egasi ?? null;
    return keyingi.handle().pipe(mergeMap((javob: unknown) =>
      from((async () => {
        try {
          // obyekt identifikatori — yo'l parametri (:id yoki :kalit)
          const id = req.params["id"] ?? req.params["kalit"];
          await auditYoz(pool, {
            aktyor, amal: b.amal, obyekt: b.obyekt ?? null,
            obyektId: typeof id === "string" ? id : null,
            sorovId: req.sorovId,
            tafsilot: {
              metod: req.method,
              yol: req.originalUrl.split("?")[0] ?? "",
            },
          });
        } catch (err) {
          joriyLog(this.log).error(
            { err, audit: b.amal }, "audit yozilmadi");
        }
        return javob;
      })())));
  }
}

const Royxat = z.strictObject({
  keyin: z.coerce.number().int().min(0).default(0),
  limit: z.coerce.number().int().min(1).max(100).default(50),
});

/** GET /v1/admin/audit — jurnal (keyset),
 * POST /v1/admin/audit/tekshir — hash zanjiri butunligi */
@Controller("admin/audit")
@Rollar("admin")
export class AuditController {
  constructor(
    @Inject(AUTH) private readonly auth: AuthBogliqliklari,
  ) {}

  @Get()
  async royxat(
    @Query({ schema: Royxat }) q: z.output<typeof Royxat>,
  ): Promise<object> {
    const { rows } = await this.auth.pool.query<
      Record<string, unknown>>(
      `SELECT id::int, vaqt, aktyor_id::int AS "aktyorId", amal,
              obyekt, obyekt_id AS "obyektId", tafsilot,
              sorov_id AS "sorovId", encode(hash, 'hex') AS hash
         FROM audit.jurnal WHERE id > $1 ORDER BY id LIMIT $2`,
      [q.keyin, q.limit]);
    return {
      yozuvlar: rows,
      keyingi: rows.length === q.limit ? rows.at(-1)?.["id"] : null,
    };
  }

  @Post("tekshir")
  @HttpCode(200)
  async tekshir(): Promise<object> {
    const { rows } = await this.auth.pool.query<
      { id: string; sabab: string }>(
      "SELECT id, sabab FROM audit_tekshir()");
    const { rows: [n] } = await this.auth.pool.query<{ n: number }>(
      "SELECT count(*)::int AS n FROM audit.jurnal");
    return {
      butun: rows.length === 0,
      yozuvlar: n?.n ?? 0,
      buzilganlar: rows.map((r) => ({
        id: Number(r.id), sabab: r.sabab,
      })),
    };
  }
}

import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE }
  from "@nestjs/core";
import { AuditController, AuditInterceptor } from "./audit/audit.ts";

// ilova modulining ichida:
// 31: admin audit jurnali (auth bilan)
controllers: authYoqilgan
  ? [IchkiController, AuditController]
  : [IchkiController],
providers: [
  // ... mavjud guard'lar va filtr
  // @Audit(...) belgilangan handler muvaffaqiyatli tugasa — jurnalga
  { provide: APP_INTERCEPTOR, useClass: AuditInterceptor },
],

import { Audit } from "../audit/audit.ts";

@Post("foydalanuvchilar/:id/bloklash")
@Audit("admin.bloklash", "foydalanuvchi")
@HttpCode(204)
async bloklash(/* ... */) {}

@Post("foydalanuvchilar/:id/blokdan-chiqarish")
@Audit("admin.blokdan_chiqarish", "foydalanuvchi")
@HttpCode(204)
async blokdanChiqarish(/* ... */) {}

@Delete("men")
@Audit("hisob.ochirildi", "foydalanuvchi")

@Post("api-kalitlar")
@Audit("api_kalit.yaratildi", "api_kalit")

@Delete("api-kalitlar/:id")
@Audit("api_kalit.bekor", "api_kalit")

// prodakshn.test.ts — audit jurnali (sql/305: faqat qo'shiladi,
// hash zanjiri). Auth test bazasi kerak; bo'lmasa SKIP.
import { afterAll, beforeEach, test } from "vitest";
import assert from "node:assert/strict";
import request from "supertest";
import { expressIlova } from "./yordamchi.ts";
import { PgOmbori } from "../src/vazifalar/pg-ombor.ts";
import { SoxtaProvayder } from "../src/ai/soxta.ts";
import {
  authBaza, authBogliqliklari, hisobOch, PAROL, tozala,
} from "./auth-yordam.ts";

const baza = await authBaza("prodakshn");
if (typeof baza === "string") {
  test.skip(`audit (Postgres) — ${baza}`, () => {});
} else {
  const pool = baza;
  afterAll(() => pool.end());
  beforeEach(() => tozala(pool));
  const tayyorla = async () => {
    const d = authBogliqliklari(pool);
    const p = new SoxtaProvayder({
      javob: () => JSON.stringify({
        qadamlar: [
          { matn: "a", daqiqa: 1 }, { matn: "b", daqiqa: 2 },
        ],
      }),
    });
    const app = await expressIlova({
      ombor: (e) => new PgOmbori(pool, e), auth: d,
      ai: { pool, provayder: p },
    });
    const admin = await hisobOch(app, d, "bekzod@example.com");
    const aziz = await hisobOch(app, d, "aziz@example.com");
    await pool.query("UPDATE foydalanuvchilar SET rol = 'admin' "
      + "WHERE email = 'bekzod@example.com'");
    const id = async (email: string) => Number((await pool.query<
      { id: string }>(
      "SELECT id FROM foydalanuvchilar WHERE email = $1",
      [email])).rows[0]?.id);
    return {
      app, admin, aziz,
      adminId: await id("bekzod@example.com"),
      azizId: await id("aziz@example.com"),
    };
  };
  const jurnal = async () => (await pool.query<{
    aktyor_id: string | null; amal: string; obyekt_id: string | null;
  }>("SELECT aktyor_id, amal, obyekt_id FROM audit.jurnal "
    + "ORDER BY id")).rows;

  test("#23 audit: muvaffaqiyatli amal yoziladi, 403 — yo'q; "
    + "zanjir butun → buzilsa topiladi", async () => {
    const { app, admin, aziz, adminId, azizId } = await tayyorla();
    const A = "/v1/admin/foydalanuvchilar";
    const oldin = (await jurnal()).length;
    await request(app).post(`${A}/${String(adminId)}/bloklash`)
      .set("Cookie", aziz).expect(403);
    await request(app).post(`${A}/${String(azizId)}/bloklash`)
      .set("Cookie", admin).expect(204);
    await request(app)
      .post(`${A}/${String(azizId)}/blokdan-chiqarish`)
      .set("Cookie", admin).expect(204);
    await request(app).post("/v1/auth/api-kalitlar")
      .set("Cookie", admin)
      .send({ nom: "ci", ruxsatlar: ["vazifalar:oqish"] })
      .expect(201);
    const j = (await jurnal()).slice(oldin);
    assert.deepEqual(j.map((x) => [x.amal,
      x.aktyor_id === null ? null : Number(x.aktyor_id),
      x.obyekt_id]), [
      ["admin.bloklash", adminId, String(azizId)],
      ["admin.blokdan_chiqarish", adminId, String(azizId)],
      ["api_kalit.yaratildi", adminId, null],
    ]);
    const l = (await request(app).get("/v1/admin/audit")
      .set("Cookie", admin).expect(200)).body as {
      yozuvlar: { amal: string; hash: string }[];
    };
    assert.match(l.yozuvlar.at(-1)?.hash ?? "", /^[0-9a-f]{64}$/);
    // bloklash Azizning HAMMA sessiyalarini bekor qilgan
    await request(app).get("/v1/admin/audit").set("Cookie", aziz)
      .expect(401);
    const t0 = await request(app).post("/v1/admin/audit/tekshir")
      .set("Cookie", admin).expect(200);
    assert.deepEqual(t0.body,
      { butun: true, yozuvlar: j.length + oldin, buzilganlar: [] });
    await assert.rejects(
      pool.query("UPDATE audit.jurnal SET amal = 'yashirin.amal'"),
      /faqat qo'shiladi/);
    await assert.rejects(pool.query("DELETE FROM audit.jurnal"),
      /faqat qo'shiladi/);
    // "superuser trigger'ni o'chirib tahrirladi" — zanjir ko'rsatadi
    await pool.query(
      "ALTER TABLE audit.jurnal DISABLE TRIGGER jurnal_ozgarmas");
    const birinchi = (await pool.query<{ id: string }>(
      "SELECT min(id) AS id FROM audit.jurnal "
      + "WHERE amal = 'admin.bloklash'")).rows[0]?.id;
    await pool.query("UPDATE audit.jurnal SET tafsilot = "
      + "'{\"metod\":\"GET\"}' WHERE id = $1", [birinchi]);
    await pool.query(
      "ALTER TABLE audit.jurnal ENABLE TRIGGER jurnal_ozgarmas");
    const t = (await request(app).post("/v1/admin/audit/tekshir")
      .set("Cookie", admin).expect(200)).body as {
      butun: boolean; buzilganlar: { id: number; sabab: string }[];
    };
    assert.equal(t.butun, false);
    assert.deepEqual(t.buzilganlar.map((x) => x.id),
      [Number(birinchi)]);
  });

  test("#23 audit: hisob o'chirish — aktyor o'zi "
    + "(amaldan keyin sessiya yo'q bo'lsa ham)", async () => {
    const { app, aziz, azizId } = await tayyorla();
    await request(app).delete("/v1/auth/men").set("Cookie", aziz)
      .send({ parol: PAROL }).expect(204);
    const j = (await jurnal())
      .filter((x) => x.amal === "hisob.ochirildi");
    assert.deepEqual(j.map((x) => Number(x.aktyor_id)), [azizId]);
  });
}

 ✓ |asosiy| test/prodakshn.test.ts (2 tests) 2636ms
   ✓ #23 audit: muvaffaqiyatli amal yoziladi, 403 — yo'q; zanjir butun → buzilsa topiladi 1945ms
   ✓ #23 audit: hisob o'chirish — aktyor o'zi (amaldan keyin sessiya yo'q bo'lsa ham) 686ms

SET session_replication_role = replica;
UPDATE audit.jurnal SET amal = 'sinov.yashirin' WHERE id = 4;
RESET session_replication_role;
SELECT * FROM audit_tekshir();

SET
UPDATE 1
RESET
 id |                               sabab
----+--------------------------------------------------------------------
  1 | hash mos emas (yozuv o'zgartirilgan)
  3 | oldingi_hash zanjirga mos emas (yozuv o'chirilgan yoki qo'shilgan)
  4 | hash mos emas (yozuv o'zgartirilgan)
(3 rows)