import { isMainThread } from "node:worker_threads" import pg from "pg" import { drizzle } from "drizzle-orm/node-postgres" import { env } from "../config.js" import * as schema from "./schema.js" import { bindSql } from "./sql-bind.js" import { DatabaseRuntimeSourceRefused, readRuntimeDatabasePoolOptions, type DatabaseArchivePeer } from "./database-runtime-source.js" const INT8_OID = 20 const DATE_OID = 1082 pg.types.setTypeParser(INT8_OID, (val) => { const n = Number(val) return Number.isSafeInteger(n) ? n : val }) pg.types.setTypeParser(DATE_OID, (val) => val) class RuntimeCheckedPool extends pg.Pool { constructor( options: pg.PoolConfig, private readonly checkCheckout: (client: pg.PoolClient) => Promise, readonly checkActivation?: () => void, readonly archivePeer?: (client: pg.ClientBase) => DatabaseArchivePeer, readonly readWriterHead?: (client: pg.ClientBase) => Promise<{ epoch: string; sha256: string; issuedAt: number }>, ) { super(options) } connect(): Promise connect(callback: (error: Error | undefined, client: pg.PoolClient | undefined, done: (release?: Error | boolean) => void) => void): void connect(callback?: (error: Error | undefined, client: pg.PoolClient | undefined, done: (release?: Error | boolean) => void) => void): Promise | void { const check = async (client: pg.PoolClient) => { let connectionFailed = false const onError = () => { connectionFailed = true } // pg-pool has removed its idle listener and the caller does not own the client yet. client.on("error", onError) try { await this.checkCheckout(client) if (connectionFailed) throw new DatabaseRuntimeSourceRefused() return client } catch { client.release(true) throw new DatabaseRuntimeSourceRefused() } finally { client.removeListener("error", onError) } } if (!callback) return super.connect().then(check) return super.connect((error, client, done) => { if (error || !client) return callback(error ?? new DatabaseRuntimeSourceRefused(), undefined, done) void check(client).then( () => callback(undefined, client, done), (error: Error) => callback(error, undefined, () => {}), ) }) } } export function createPool(max = 16, allowExitOnIdle = process.env.NODE_ENV === "test"): pg.Pool { const { archivePeer, checkActivation, checkCheckout, readWriterHead, ...connection } = readRuntimeDatabasePoolOptions({ databaseUrl: env.DATABASE_URL, requestFile: process.env.DATABASE_RUNTIME_REQUEST_FILE, requestSha256: process.env.DATABASE_RUNTIME_REQUEST_SHA256, caFile: process.env.DATABASE_RUNTIME_CA_FILE, activationDirectory: process.env.DATABASE_RUNTIME_ACTIVATION_DIRECTORY, activationSha256: process.env.DATABASE_RUNTIME_ACTIVATION_SHA256, writerApprovalFile: process.env.DATABASE_RUNTIME_WRITER_APPROVAL_FILE, writerApprovalSha256: process.env.DATABASE_RUNTIME_WRITER_APPROVAL_SHA256, }) if (connection.onConnect && !process.env.DATABASE_URL) throw new DatabaseRuntimeSourceRefused() const options = { ...connection, max, idleTimeoutMillis: 30_000, allowExitOnIdle, connectionTimeoutMillis: 8_000, statement_timeout: 120_000, } const pool = checkCheckout ? new RuntimeCheckedPool(options, checkCheckout, checkActivation, archivePeer, readWriterHead) : new pg.Pool(options) if (connection.onConnect) pool.on("error", () => console.error("Потеряно проверяемое соединение приложения с PostgreSQL")) return pool } export const pool = createPool(isMainThread ? 16 : 4) export function assertRuntimeDatabaseActivationCurrent(): void { if (pool instanceof RuntimeCheckedPool) pool.checkActivation?.() } export async function readRuntimeDatabaseWriterHead(client: unknown) { if (!(pool instanceof RuntimeCheckedPool) || !pool.readWriterHead) return undefined if (!(client instanceof pg.Client)) throw new DatabaseRuntimeSourceRefused() return pool.readWriterHead(client) } export function readRuntimeDatabaseArchivePeer(client: unknown): DatabaseArchivePeer { if (!(pool instanceof RuntimeCheckedPool) || !pool.archivePeer || !(client instanceof pg.Client)) throw new DatabaseRuntimeSourceRefused() return pool.archivePeer(client) } export const db = drizzle(pool, { schema }) export async function dbQuery( text: string, params?: unknown[] | Record, ): Promise> { const q = bindSql(text, params) return pool.query(q) } export async function dbAll( text: string, params?: unknown[] | Record, ): Promise { const res = await dbQuery(text, params) return res.rows } export async function dbGet( text: string, params?: unknown[] | Record, ): Promise { const rows = await dbAll(text, params) return rows[0] } export async function withAdvisoryLock(key: number, fn: () => Promise): Promise { const client = await pool.connect() try { await client.query("SELECT pg_advisory_lock($1)", [key]) return await fn() } finally { try { await client.query("SELECT pg_advisory_unlock($1)", [key]) } catch { /* ignore */ } client.release() } } export async function closePool(): Promise { await pool.end() }