@onreza/sqlx-js 0.0.0 → 0.2.0

package/dist/src/commands/prepare.d.ts

@@ -1,4 +1,4 @@
-import { PgClient } from "../pg/wire.js";
+import { PgClient, type ConnConfig, type FieldDescription } from "../pg/wire.js";
 import { SchemaCache } from "../pg/schema.js";
 import { type SqlxJsConfig } from "../config.js";
 export type PrepareOptions = {
@@ -15,9 +15,23 @@ export type PrepareSession = {
     userCfg: SqlxJsConfig;
 };
 export declare function openSession(opts: PrepareOptions): Promise<PrepareSession>;
-export declare function prepareOnce(opts: PrepareOptions, session: PrepareSession, log?: (msg: string) => void, err?: (msg: string) => void): Promise<{
+type DescribeOutcome = {
+    ok: true;
+    paramOids: number[];
+    fields: FieldDescription[];
+} | {
+    ok: false;
+    error: unknown;
+};
+export declare function defaultPrepareConcurrency(): number;
+export declare function describeAll(cfg: ConnConfig, sessionClient: PgClient, queries: {
+    fp: string;
+    query: string;
+}[], concurrency: number): Promise<Map<string, DescribeOutcome>>;
+export declare function prepareOnce(opts: PrepareOptions, session: PrepareSession, log?: (msg: string) => void, err?: (msg: string) => void, concurrency?: number): Promise<{
     entries: number;
     failures: number;
     pruned: number;
 }>;
 export declare function runPrepare(opts: PrepareOptions): Promise<void>;
+export {};

package/dist/src/commands/prepare.js

@@ -1,5 +1,5 @@
 import { PgClient, parseDatabaseUrl, PgError } from "../pg/wire.js";
-import { SchemaCache } from "../pg/schema.js";
+import { SchemaCache, compositeLiteral } from "../pg/schema.js";
 import { analyzeQuery } from "../pg/analyze.js";
 import { isBuiltinOid, oidToTs } from "../pg/oids.js";
 import { scanProject } from "../scan/scanner.js";
@@ -26,6 +26,10 @@ function resolveTs(oid, customLookup) {
             return c.tsType;
         if (c.kind === "scalarArray")
             return `(${c.element.tsType})[]`;
+        if (c.kind === "composite")
+            return compositeLiteral(c);
+        if (c.kind === "compositeArray")
+            return `(${compositeLiteral(c.element)})[]`;
     }
     return oidToTs(oid).ts;
 }
@@ -105,7 +109,59 @@ export async function openSession(opts) {
     schema.setTypeRegistry(mergeExtensionTypes(userCfg.customTypes));
     return { client, schema, userCfg };
 }
-export async function prepareOnce(opts, session, log = console.log, err = console.error) {
+export function defaultPrepareConcurrency() {
+    const raw = process.env.SQLX_JS_PREPARE_CONCURRENCY;
+    const n = raw ? Number(raw) : NaN;
+    return Number.isFinite(n) && n >= 1 ? Math.floor(n) : 8;
+}
+// describe() is sequential per PgClient (see wire.ts), so concurrency comes from
+// running several short-lived connections in parallel, each draining a shared
+// cursor. The session connection is reused as one worker; extras are closed after.
+export async function describeAll(cfg, sessionClient, queries, concurrency) {
+    const results = new Map();
+    if (queries.length === 0)
+        return results;
+    const workerCount = Math.max(1, Math.min(concurrency, queries.length));
+    let cursor = 0;
+    const drain = async (client) => {
+        while (true) {
+            const i = cursor++;
+            if (i >= queries.length)
+                return;
+            const { fp, query } = queries[i];
+            try {
+                const d = await client.describe(query);
+                results.set(fp, { ok: true, paramOids: d.paramOids, fields: d.fields });
+            }
+            catch (error) {
+                results.set(fp, { ok: false, error });
+            }
+        }
+    };
+    const extras = [];
+    try {
+        // Open extra connections best-effort. The session connection alone is enough
+        // to drain the queue, so a connection-limited server (low max_connections,
+        // PgBouncer) degrades to fewer workers instead of failing the whole prepare.
+        for (let i = 1; i < workerCount; i++) {
+            const c = new PgClient(cfg);
+            try {
+                await c.connect();
+            }
+            catch {
+                await c.end().catch(() => { });
+                break;
+            }
+            extras.push(c);
+        }
+        await Promise.all([sessionClient, ...extras].map((c) => drain(c)));
+    }
+    finally {
+        await Promise.all(extras.map((c) => c.end().catch(() => { })));
+    }
+    return results;
+}
+export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency()) {
     const sites = scanProject(opts.root);
     log(`scanned: found ${sites.length} sql() call site(s)`);
     const cache = new Cache(opts.cacheDir);
@@ -121,30 +177,32 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
     const raw = [];
     let failures = 0;
     const { client, schema, userCfg } = session;
+    const describeList = [...unique.values()].map((u) => ({ fp: u.fp, query: u.query }));
+    const describeResults = await describeAll(parseDatabaseUrl(opts.databaseUrl), client, describeList, concurrency);
     for (const { fp, query, sites: ss } of unique.values()) {
         const site = ss[0];
-        try {
-            const d = await client.describe(query);
-            raw.push({ fp, query, sites: ss, paramOids: d.paramOids, fields: d.fields });
+        const outcome = describeResults.get(fp);
+        if (outcome.ok) {
+            raw.push({ fp, query, sites: ss, paramOids: outcome.paramOids, fields: outcome.fields });
+            continue;
         }
-        catch (e) {
-            failures++;
-            if (e instanceof PgError) {
-                const extras = [];
-                if (e.position)
-                    extras.push(`pos ${e.position}`);
-                if (e.code)
-                    extras.push(`code ${e.code}`);
-                const tail = extras.length > 0 ? ` (${extras.join(", ")})` : "";
-                err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}${tail}`);
-                if (e.hint)
-                    err(`      hint: ${e.hint}`);
-                err(`      query: ${snippet(query)}`);
-            }
-            else {
-                err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
-                err(`      query: ${snippet(query)}`);
-            }
+        failures++;
+        const e = outcome.error;
+        if (e instanceof PgError) {
+            const extras = [];
+            if (e.position)
+                extras.push(`pos ${e.position}`);
+            if (e.code)
+                extras.push(`code ${e.code}`);
+            const tail = extras.length > 0 ? ` (${extras.join(", ")})` : "";
+            err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}${tail}`);
+            if (e.hint)
+                err(`      hint: ${e.hint}`);
+            err(`      query: ${snippet(query)}`);
+        }
+        else {
+            err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
+            err(`      query: ${snippet(query)}`);
         }
     }
     const allAttrRefs = [];

package/dist/src/commands/schema.js

@@ -14,6 +14,10 @@ export async function applyShadowMigrations(databaseUrl, migrationsDir, log = co
                 applied++;
                 log(`shadow: applied ${String(e.version).padStart(4, "0")}_${e.name}`);
             }
+            else if (e.kind === "adopted") {
+                applied++;
+                log(`shadow: adopted ${String(e.version).padStart(4, "0")}_${e.name} (${e.replaced} replaced)`);
+            }
             else if (e.kind === "tampered") {
                 throw new Error(`sqlx-js shadow: ${e.version}_${e.name} hash mismatch (applied ${e.applied.slice(0, 16)} vs current ${e.current.slice(0, 16)})`);
             }

package/dist/src/commands/watch.js

@@ -21,7 +21,7 @@ export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_D
     }
     if (!state.session)
         state.session = await deps.openSession(opts);
-    return await deps.prepareOnce(opts, state.session, log, err);
+    return await deps.prepareOnce(opts, state.session, log, err, 1);
 }
 export async function runWatch(opts) {
     const stamp = () => new Date().toTimeString().slice(0, 8);

package/dist/src/index.d.ts

@@ -8,8 +8,8 @@ export type { SqlxJsConfig } from "./config.js";
 export type { SslMode, ConnConfig } from "./pg/wire.js";
 export { PgError, ConnectionLostError } from "./pg/wire.js";
 export { NoRowsError, TooManyRowsError } from "./runtime.js";
-export type { TransactionOptions, MigrateOptions } from "./runtime.js";
-export type { PostgresClient, PostgresOptions } from "./postgres-runtime.js";
+export type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook } from "./runtime.js";
+export type { PostgresClient, PostgresOptions, CreateClientOptions } from "./postgres-runtime.js";
 export type TypedFile = TypedFileFor<KnownFileQueries>;
 export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
 export type Typed = TypedFor<KnownQueries, KnownFileQueries, import("./runtime.js").TransactionOptions>;

package/dist/src/pg/narrow.js

@@ -78,6 +78,14 @@ function walk(node) {
             }
             return forcedInfo(acc ?? []);
         }
+        if (op === "NOT_EXPR") {
+            const arg = args[0];
+            if (arg?.NullTest?.nulltesttype === "IS_NULL") {
+                const k = keyOfColumnRef(arg.NullTest.arg);
+                return k ? forcedInfo([k]) : emptyInfo();
+            }
+            return emptyInfo();
+        }
         return emptyInfo();
     }
     if (node.A_Expr) {

package/dist/src/pg/schema.d.ts

@@ -24,7 +24,23 @@ export type ScalarArrayInfo = {
     name: string;
     element: ScalarInfo;
 };
-export type CustomTypeInfo = EnumInfo | EnumArrayInfo | ScalarInfo | ScalarArrayInfo;
+export type CompositeField = {
+    name: string;
+    tsType: string;
+    nullable: boolean;
+};
+export type CompositeInfo = {
+    kind: "composite";
+    name: string;
+    fields: CompositeField[];
+};
+export type CompositeArrayInfo = {
+    kind: "compositeArray";
+    name: string;
+    element: CompositeInfo;
+};
+export type CustomTypeInfo = EnumInfo | EnumArrayInfo | ScalarInfo | ScalarArrayInfo | CompositeInfo | CompositeArrayInfo;
+export declare function compositeLiteral(info: CompositeInfo): string;
 export declare class SchemaCache {
     private client;
     private byOidNum;

package/dist/src/pg/schema.js

@@ -1,5 +1,14 @@
 import { decodeText } from "./wire.js";
 import { isBuiltinOid, oidToTs } from "./oids.js";
+export function compositeLiteral(info) {
+    if (info.fields.length === 0)
+        return "Record<string, unknown>";
+    const parts = info.fields.map((f) => {
+        const name = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(f.name) ? f.name : JSON.stringify(f.name);
+        return `${name}: ${f.tsType}${f.nullable ? " | null" : ""}`;
+    });
+    return `{ ${parts.join("; ")} }`;
+}
 export class SchemaCache {
     client;
     byOidNum = new Map();
@@ -130,11 +139,12 @@ export class SchemaCache {
         for (const oid of need)
             this.typesProbed.add(oid);
         const list1 = [...new Set(need)].join(",");
-        const sql1 = `SELECT oid::int8, typname, typtype, typcategory, typelem::int8, typbasetype::int8 FROM pg_type WHERE oid IN (${list1})`;
+        const sql1 = `SELECT oid::int8, typname, typtype, typcategory, typelem::int8, typbasetype::int8, typrelid::int8 FROM pg_type WHERE oid IN (${list1})`;
         const r1 = await this.client.simpleQueryAll(sql1);
         const enumOids = [];
         const arrayInfos = [];
         const domainInfos = [];
+        const compositeInfos = [];
         for (const row of r1.rows) {
             const oid = Number(decodeText(row[0]));
             const name = decodeText(row[1]);
@@ -142,6 +152,7 @@ export class SchemaCache {
             const typcategory = decodeText(row[3]);
             const typelem = Number(decodeText(row[4]));
             const typbasetype = Number(decodeText(row[5]));
+            const typrelid = Number(decodeText(row[6]));
             if (typtype === "e") {
                 enumOids.push(oid);
                 this.customTypes.set(oid, { kind: "enum", name, values: [] });
@@ -155,10 +166,29 @@ export class SchemaCache {
             else if (typtype === "d" && typbasetype > 0) {
                 domainInfos.push({ oid, name, baseOid: typbasetype });
             }
+            else if (typtype === "c" && typrelid > 0) {
+                compositeInfos.push({ oid, name, relOid: typrelid });
+            }
+        }
+        const compositeAttrs = new Map();
+        if (compositeInfos.length > 0) {
+            const relList = [...new Set(compositeInfos.map((c) => c.relOid))].join(",");
+            const sqlc = `SELECT c.oid::int8, a.attname, a.atttypid::int8, a.attnotnull FROM pg_attribute a JOIN pg_type c ON c.typrelid = a.attrelid WHERE a.attrelid IN (${relList}) AND a.attnum > 0 AND NOT a.attisdropped ORDER BY c.oid, a.attnum`;
+            const rc = await this.client.simpleQueryAll(sqlc);
+            for (const row of rc.rows) {
+                const typoid = Number(decodeText(row[0]));
+                const attname = decodeText(row[1]);
+                const atttypid = Number(decodeText(row[2]));
+                const notNull = decodeText(row[3]) === "t";
+                const arr = compositeAttrs.get(typoid) ?? [];
+                arr.push({ name: attname, typeOid: atttypid, notNull });
+                compositeAttrs.set(typoid, arr);
+            }
         }
         const elemsToProbe = arrayInfos.map((a) => a.elemOid).filter((o) => !this.typesProbed.has(o));
         const basesToProbe = domainInfos.map((d) => d.baseOid).filter((o) => !this.typesProbed.has(o) && !isBuiltinOid(o));
-        const recurse = [...new Set([...elemsToProbe, ...basesToProbe])];
+        const fieldsToProbe = [...compositeAttrs.values()].flat().map((f) => f.typeOid).filter((o) => !this.typesProbed.has(o) && !isBuiltinOid(o));
+        const recurse = [...new Set([...elemsToProbe, ...basesToProbe, ...fieldsToProbe])];
         if (recurse.length > 0)
             await this.loadCustomTypes(recurse);
         for (const { oid, name, baseOid } of domainInfos) {
@@ -167,6 +197,15 @@ export class SchemaCache {
                 this.customTypes.set(oid, { kind: "scalar", name, tsType: resolved });
             }
         }
+        for (const { oid, name } of compositeInfos) {
+            const attrs = compositeAttrs.get(oid) ?? [];
+            const fields = attrs.map((a) => ({
+                name: a.name,
+                tsType: this.resolveBaseTs(a.typeOid) ?? "unknown",
+                nullable: !a.notNull,
+            }));
+            this.customTypes.set(oid, { kind: "composite", name, fields });
+        }
         for (const { arrayOid, arrayName, elemOid } of arrayInfos) {
             const elem = this.customTypes.get(elemOid);
             if (elem && elem.kind === "enum") {
@@ -175,6 +214,9 @@ export class SchemaCache {
             else if (elem && elem.kind === "scalar") {
                 this.customTypes.set(arrayOid, { kind: "scalarArray", name: arrayName, element: elem });
             }
+            else if (elem && elem.kind === "composite") {
+                this.customTypes.set(arrayOid, { kind: "compositeArray", name: arrayName, element: elem });
+            }
         }
         if (enumOids.length > 0) {
             const list2 = enumOids.join(",");
@@ -211,6 +253,10 @@ export class SchemaCache {
                 return "string[]";
             return `(${info.element.values.map((v) => JSON.stringify(v)).join(" | ")})[]`;
         }
+        if (info.kind === "composite")
+            return compositeLiteral(info);
+        if (info.kind === "compositeArray")
+            return `(${compositeLiteral(info.element)})[]`;
         return undefined;
     }
     customType(oid) {

package/dist/src/pg/wire.d.ts

@@ -9,6 +9,10 @@ export type ConnConfig = {
     sslmode?: SslMode;
     applicationName?: string;
     connectTimeoutMs?: number;
+    statementTimeoutMs?: number;
+    sslRootCert?: string;
+    sslCert?: string;
+    sslKey?: string;
 };
 export declare function parseDatabaseUrl(url: string): ConnConfig;
 export type ServerMessage = {
@@ -91,6 +95,9 @@ export declare class PgClient {
     constructor(cfg: ConnConfig);
     get usingTls(): boolean;
     connect(): Promise<void>;
+    private destroySocket;
+    private connectInner;
+    private abortConnect;
     private attachHandlers;
     private deliver;
     private flushWaiters;
@@ -120,12 +127,18 @@ export declare function computeScramProof(password: string, salt: Uint8Array, it
 };
 export declare class PgError extends Error {
     fields: Record<string, string>;
-    constructor(fields: Record<string, string>);
+    constructor(fields: Record<string, string>, options?: {
+        cause?: unknown;
+    });
     get code(): string | undefined;
     get position(): number | undefined;
     get hint(): string | undefined;
     get detail(): string | undefined;
     get severity(): string | undefined;
+    get schema(): string | undefined;
+    get table(): string | undefined;
+    get column(): string | undefined;
+    get constraint(): string | undefined;
 }
 export declare class ConnectionLostError extends Error {
     readonly cause: Error;

package/dist/src/pg/wire.js

@@ -1,4 +1,5 @@
 import { createHash, createHmac, pbkdf2Sync, randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { connect as netConnect } from "node:net";
 import { connect as tlsConnect } from "node:tls";
 const textEncoder = new TextEncoder();
@@ -31,6 +32,21 @@ export function parseDatabaseUrl(url) {
         if (Number.isFinite(n) && n > 0)
             cfg.connectTimeoutMs = n * 1000;
     }
+    const st = params.get("statement_timeout");
+    if (st) {
+        const n = Number(st);
+        if (Number.isFinite(n) && n >= 0)
+            cfg.statementTimeoutMs = n;
+    }
+    const sslRootCert = params.get("sslrootcert");
+    if (sslRootCert)
+        cfg.sslRootCert = sslRootCert;
+    const sslCert = params.get("sslcert");
+    if (sslCert)
+        cfg.sslCert = sslCert;
+    const sslKey = params.get("sslkey");
+    if (sslKey)
+        cfg.sslKey = sslKey;
     return cfg;
 }
 export class MessageReader {
@@ -229,6 +245,14 @@ function frame(tag, body) {
 function isTlsRequired(mode) {
     return mode === "require" || mode === "verify-ca" || mode === "verify-full";
 }
+function readCertFile(kind, path) {
+    try {
+        return readFileSync(path);
+    }
+    catch (e) {
+        throw new Error(`sqlx-js: cannot read ${kind} at ${path}: ${e.message}`);
+    }
+}
 async function openPlainSocket(host, port, timeoutMs) {
     return new Promise((resolve, reject) => {
         const sock = netConnect({ host, port });
@@ -275,6 +299,9 @@ async function performSslHandshake(sock, cfg, mode) {
                 servername: cfg.host,
                 rejectUnauthorized: mode === "verify-full" || mode === "verify-ca",
                 checkServerIdentity: mode === "verify-full" ? undefined : () => undefined,
+                ...(cfg.sslRootCert ? { ca: readCertFile("sslrootcert", cfg.sslRootCert) } : {}),
+                ...(cfg.sslCert ? { cert: readCertFile("sslcert", cfg.sslCert) } : {}),
+                ...(cfg.sslKey ? { key: readCertFile("sslkey", cfg.sslKey) } : {}),
             });
             t.once("secureConnect", () => resolve(t));
             t.once("error", (err) => {
@@ -308,9 +335,42 @@ export class PgClient {
     }
     get usingTls() { return this.tlsEnabled; }
     async connect() {
-        const mode = this.cfg.sslmode ?? "prefer";
         const timeoutMs = this.cfg.connectTimeoutMs ?? 15000;
+        let aborted = false;
+        let timer;
+        const deadline = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                aborted = true;
+                const err = new Error(`sqlx-js: connect timeout to ${this.cfg.host}:${this.cfg.port} after ${timeoutMs}ms (includes TLS + authentication)`);
+                this.closed = true;
+                this.closeReason ??= err;
+                this.destroySocket();
+                reject(err);
+            }, timeoutMs);
+        });
+        try {
+            await Promise.race([this.connectInner(timeoutMs, () => aborted), deadline]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    destroySocket() {
+        try {
+            this.sock?.destroy();
+        }
+        catch { /* ignore */ }
+    }
+    // Cooperative cancellation: a socket can finish connecting after the deadline
+    // has already rejected. Re-check `aborted` at each await boundary so a late
+    // connection is torn down instead of leaking.
+    async connectInner(timeoutMs, aborted) {
+        const mode = this.cfg.sslmode ?? "prefer";
         const plain = await openPlainSocket(this.cfg.host, this.cfg.port, timeoutMs);
+        this.sock = plain;
+        if (aborted())
+            return this.abortConnect();
         let socket = plain;
         if (mode !== "disable") {
             const result = await performSslHandshake(plain, this.cfg, mode);
@@ -318,11 +378,17 @@ export class PgClient {
             this.tlsEnabled = result.tls;
         }
         this.sock = socket;
+        if (aborted())
+            return this.abortConnect();
         this.attachHandlers();
         await this.startup();
         await this.authenticate();
         await this.awaitReady();
     }
+    abortConnect() {
+        this.destroySocket();
+        throw this.closeReason ?? new Error("sqlx-js: connect aborted");
+    }
     attachHandlers() {
         const onData = (chunk) => {
             for (const m of this.reader.push(chunk))
@@ -380,6 +446,9 @@ export class PgClient {
         if (this.cfg.applicationName) {
             pairs.push(cstr("application_name"), cstr(this.cfg.applicationName));
         }
+        if (this.cfg.statementTimeoutMs !== undefined) {
+            pairs.push(cstr("statement_timeout"), cstr(String(this.cfg.statementTimeoutMs)));
+        }
         pairs.push(new Uint8Array([0]));
         const body = concat([writeInt32(196608), concat(pairs)]);
         this.write(frame(null, body));
@@ -678,16 +747,25 @@ function stringifyMessage(m) {
 }
 export class PgError extends Error {
     fields;
-    constructor(fields) {
-        super(fields.M ?? "postgres error");
+    constructor(fields, options) {
+        super(fields.M ?? "postgres error", options);
         this.fields = fields;
         this.name = "PgError";
+        // Bun attaches own `line`/`column` properties to every Error instance, which
+        // would shadow the prototype getters below. Drop them so `.column` resolves
+        // to the PG column name, not the engine's source position.
+        delete this.line;
+        delete this.column;
     }
     get code() { return this.fields.C; }
     get position() { return this.fields.P ? Number(this.fields.P) : undefined; }
     get hint() { return this.fields.H; }
     get detail() { return this.fields.D; }
     get severity() { return this.fields.S; }
+    get schema() { return this.fields.s; }
+    get table() { return this.fields.t; }
+    get column() { return this.fields.c; }
+    get constraint() { return this.fields.n; }
 }
 export class ConnectionLostError extends Error {
     cause;

package/dist/src/postgres-runtime.d.ts

@@ -1,11 +1,18 @@
 import postgres from "postgres";
+import { type OnQueryHook } from "./runtime.js";
 export type PostgresClient = postgres.Sql<{
     bigint: bigint;
 }>;
 export type PostgresOptions = postgres.Options<Record<string, postgres.PostgresType>>;
-export declare function createClient(url?: string | undefined, options?: PostgresOptions): PostgresClient;
+export type CreateClientOptions = PostgresOptions & {
+    onQuery?: OnQueryHook;
+    statementTimeoutMs?: number;
+};
+export declare function createClient(url?: string | undefined, options?: CreateClientOptions): PostgresClient;
 export declare function getClient(): PostgresClient;
-export declare function setClient(client: PostgresClient): void;
+export declare function setClient(client: PostgresClient, options?: {
+    onQuery?: OnQueryHook;
+}): void;
 export declare function close(): Promise<void>;
 export declare const sql: import("./runtime.js").SqlRoot;
 export declare const unsafe: (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;

package/dist/src/postgres-runtime.js

@@ -1,10 +1,13 @@
 import postgres from "postgres";
 import { createSqlRuntime, encodeParam, encodePgArrayLiteral, parsePgArrayLiteral } from "./runtime.js";
 import { arrayElementOid, builtinArrayOids } from "./pg/oids.js";
+const HOOKS = Symbol.for("sqlx-js.hooks");
 class PostgresRuntimeClient {
     client;
-    constructor(client) {
+    onQuery;
+    constructor(client, onQuery) {
         this.client = client;
+        this.onQuery = onQuery;
     }
     async query(query, params) {
         return await this.client.unsafe(query, params, { prepare: true });
@@ -19,7 +22,7 @@ class PostgresRuntimeClient {
         if (!("begin" in this.client))
             throw new Error("sqlx-js.transaction: nested transactions are not supported");
         return await this.client.begin(async (tx) => {
-            return await fn(new PostgresRuntimeClient(tx));
+            return await fn(new PostgresRuntimeClient(tx, this.onQuery));
         });
     }
     async close() {
@@ -124,7 +127,18 @@ function postgresTypes() {
 export function createClient(url = process.env.DATABASE_URL, options = {}) {
     if (!url)
         throw new Error("sqlx-js: DATABASE_URL is not set");
-    return postgres(url, { ...options, types: { ...postgresTypes(), ...(options.types ?? {}) } });
+    const { onQuery, statementTimeoutMs, ...pgOptions } = options;
+    const connection = statementTimeoutMs !== undefined
+        ? { ...(pgOptions.connection ?? {}), statement_timeout: statementTimeoutMs }
+        : pgOptions.connection;
+    const client = postgres(url, {
+        ...pgOptions,
+        ...(connection ? { connection } : {}),
+        types: { ...postgresTypes(), ...(pgOptions.types ?? {}) },
+    });
+    if (onQuery)
+        client[HOOKS] = { onQuery };
+    return client;
 }
 function createDefaultClient() {
     return new PostgresRuntimeClient(createClient());
@@ -136,8 +150,9 @@ function getRuntimeClient() {
 export function getClient() {
     return getRuntimeClient().client;
 }
-export function setClient(client) {
-    defaultClient = new PostgresRuntimeClient(client);
+export function setClient(client, options) {
+    const attached = client[HOOKS];
+    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery);
 }
 export async function close() {
     if (defaultClient) {

package/dist/src/runtime.d.ts

@@ -1,8 +1,18 @@
+import { PgError } from "./pg/wire.js";
+export type OnQueryEvent = {
+    query: string;
+    params: unknown[];
+    durationMs: number;
+    rowCount?: number;
+    error?: unknown;
+};
+export type OnQueryHook = (event: OnQueryEvent) => void;
 export type RuntimeClient = {
     query: (query: string, params: unknown[]) => Promise<unknown[]>;
     transformParam?: (param: unknown) => unknown;
     transaction: <R>(fn: (client: RuntimeClient) => Promise<R>) => Promise<R>;
     close: () => Promise<void>;
+    onQuery?: OnQueryHook;
 };
 type AnyFn = (...args: unknown[]) => Promise<unknown[]>;
 type AnyOneFn = (...args: unknown[]) => Promise<unknown>;
@@ -21,6 +31,7 @@ export declare class TooManyRowsError extends Error {
     actual: number;
     constructor(actual: number, expected?: "1" | "0 or 1");
 }
+export declare function toPgError(e: unknown): PgError | null;
 export declare const _internal: {
     renameRows: typeof renameRows;
     encodeParam: typeof encodeParam;
@@ -29,6 +40,7 @@ export declare const _internal: {
     loadSqlFile: typeof loadSqlFile;
     buildSetTransaction: typeof buildSetTransaction;
     clearIdentifierCache: typeof clearIdentifierCache;
+    toPgError: typeof toPgError;
 };
 declare function loadSqlFile(path: string): string;
 export declare function clearSqlFileCache(): void;