@onreza/sqlx-js 0.1.0 → 0.3.0

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;

package/dist/src/runtime.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
-import { PgClient, parseDatabaseUrl } from "./pg/wire.js";
+import { PgClient, parseDatabaseUrl, PgError } from "./pg/wire.js";
 import { applyPending, acquireMigrateLock, releaseMigrateLock, DEFAULT_MIGRATE_LOCK_KEY } from "./commands/migrate.js";
 const SUFFIX = /[!?]$/;
 function renameRows(rows) {
@@ -148,6 +148,63 @@ export class TooManyRowsError extends Error {
         this.actual = actual;
     }
 }
+// SQLSTATE is exactly five characters from [0-9A-Z]; lowercase or other shapes
+// are never valid, so transport codes like "EPIPE" must not match on shape alone.
+const SQLSTATE = /^[0-9A-Z]{5}$/;
+function firstString(...candidates) {
+    for (const value of candidates) {
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+export function toPgError(e) {
+    if (e instanceof PgError)
+        return e;
+    if (e === null || typeof e !== "object")
+        return null;
+    const o = e;
+    const code = typeof o.code === "string" ? o.code : undefined;
+    // `_name` variants are postgres.js; bare forms are node-postgres. Bare
+    // `column`/`schema`/`table` can also collide with runtime-added Error
+    // properties, so we read namespaced variants first and only accept strings.
+    const severity = firstString(o.severity, o.severity_local);
+    // A genuine database error is identified by the driver's branded name
+    // (Postgres.js) or by a SQLSTATE-shaped code paired with a severity. Transport
+    // and system errors (EPIPE, ECONNREFUSED, CONNECTION_ENDED) carry neither, so
+    // they pass through untouched instead of masquerading as a PgError.
+    const isDatabaseError = o.name === "PostgresError" ||
+        (code !== undefined && SQLSTATE.test(code) && severity !== undefined);
+    if (!isDatabaseError)
+        return null;
+    const fields = {};
+    if (typeof o.message === "string" && o.message.length > 0)
+        fields.M = o.message;
+    if (code)
+        fields.C = code;
+    if (typeof o.detail === "string" && o.detail.length > 0)
+        fields.D = o.detail;
+    if (typeof o.hint === "string" && o.hint.length > 0)
+        fields.H = o.hint;
+    const position = firstString(o.position) ?? (typeof o.position === "number" && Number.isFinite(o.position) ? String(o.position) : undefined);
+    if (position)
+        fields.P = position;
+    if (severity)
+        fields.S = severity;
+    const table = firstString(o.table_name, o.table);
+    if (table)
+        fields.t = table;
+    const column = firstString(o.column_name, o.column);
+    if (column)
+        fields.c = column;
+    const constraint = firstString(o.constraint_name, o.constraint);
+    if (constraint)
+        fields.n = constraint;
+    const schema = firstString(o.schema_name, o.schema);
+    if (schema)
+        fields.s = schema;
+    return new PgError(fields, { cause: e });
+}
 export const _internal = {
     renameRows,
     encodeParam,
@@ -156,13 +213,32 @@ export const _internal = {
     loadSqlFile,
     buildSetTransaction,
     clearIdentifierCache,
+    toPgError,
 };
 async function runQuery(client, query, params) {
     const encoded = params.length === 0
         ? params
         : params.map((p) => client.transformParam ? client.transformParam(p) : encodeParam(p));
-    const rows = await client.query(query, encoded);
-    return renameRows(rows);
+    const onQuery = client.onQuery;
+    if (!onQuery) {
+        try {
+            return renameRows(await client.query(query, encoded));
+        }
+        catch (e) {
+            throw toPgError(e) ?? e;
+        }
+    }
+    const start = performance.now();
+    try {
+        const rows = await client.query(query, encoded);
+        onQuery({ query, params, durationMs: performance.now() - start, rowCount: rows.length });
+        return renameRows(rows);
+    }
+    catch (e) {
+        const error = toPgError(e) ?? e;
+        onQuery({ query, params, durationMs: performance.now() - start, error });
+        throw error;
+    }
 }
 async function runOne(client, query, params) {
     const rows = await runQuery(client, query, params);
@@ -422,6 +498,10 @@ export async function migrate(opts = {}) {
                 log(`migrate: applied ${String(e.version).padStart(4, "0")}_${e.name}`);
                 appliedAny = true;
             }
+            else if (e.kind === "adopted") {
+                log(`migrate: adopted ${String(e.version).padStart(4, "0")}_${e.name} (${e.replaced} replaced)`);
+                appliedAny = true;
+            }
             else if (e.kind === "tampered") {
                 throw new Error(`sqlx-js.migrate: ${e.version}_${e.name} hash mismatch (applied ${e.applied.slice(0, 16)}… vs current ${e.current.slice(0, 16)}…)`);
             }

package/dist/src/scan/scanner.js

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 const EXCLUDE_DIRS = new Set(["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"]);
-const SQLX_MODULES = new Set(["@onreza/sqlx-js", "@onreza/sqlx-js/bun"]);
+const SQLX_MODULES = new Set(["@onreza/sqlx-js"]);
 const EXT = /\.(ts|tsx|mts|cts)$/;
 function walk(dir, out) {
     for (const name of readdirSync(dir)) {

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@onreza/sqlx-js",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Compile-time-checked raw SQL for TypeScript + PostgreSQL. Inspired by sqlx.",
   "license": "MIT",
   "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
   "sideEffects": false,
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -12,12 +15,6 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js",
       "default": "./dist/src/index.js"
-    },
-    "./bun": {
-      "types": "./dist/src/bun.d.ts",
-      "bun": "./dist/src/bun.js",
-      "import": "./dist/src/bun.js",
-      "default": "./dist/src/bun.js"
     }
   },
   "bin": {
@@ -52,7 +49,7 @@
     "migrations"
   ],
   "scripts": {
-    "prepare": "[ -d .git ] && lefthook install >/dev/null 2>&1 || true",
+    "prepare": "(test -f dist/bin/sqlx-js.js || bun run build) && ([ ! -d .git ] || lefthook install >/dev/null 2>&1 || true)",
     "test": "bun test tests",
     "test:typecheck": "tsc --noEmit",
     "test:example": "bunx tsc -p example --noEmit",

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

@@ -1,7 +0,0 @@
-import { SQL } from "bun";
-export type BunClient = SQL;
-export declare function getClient(): BunClient;
-export declare function setClient(client: BunClient): 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/bun-runtime.js

@@ -1,45 +0,0 @@
-import { SQL } from "bun";
-import { createSqlRuntime } from "./runtime.js";
-class BunRuntimeClient {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async query(query, params) {
-        return await this.client.unsafe(query, params);
-    }
-    async transaction(fn) {
-        return await this.client.begin(async (tx) => {
-            return await fn(new BunRuntimeClient(tx));
-        });
-    }
-    async close() {
-        await this.client.close();
-    }
-}
-let defaultClient = null;
-function createDefaultClient() {
-    const url = process.env.DATABASE_URL;
-    if (!url)
-        throw new Error("sqlx-js: DATABASE_URL is not set");
-    return new BunRuntimeClient(new SQL({ url, bigint: true }));
-}
-function getRuntimeClient() {
-    defaultClient ??= createDefaultClient();
-    return defaultClient;
-}
-export function getClient() {
-    return getRuntimeClient().client;
-}
-export function setClient(client) {
-    defaultClient = new BunRuntimeClient(client);
-}
-export async function close() {
-    if (defaultClient) {
-        await defaultClient.close();
-        defaultClient = null;
-    }
-}
-const runtime = createSqlRuntime(getRuntimeClient);
-export const sql = runtime.sql;
-export const unsafe = runtime.unsafe;

package/dist/src/bun.d.ts

@@ -1,22 +0,0 @@
-import * as rt from "./bun-runtime.js";
-import type { Typed as TypedFor, TypedFile as TypedFileFor, TypedSql as TypedSqlFor } from "./typed.js";
-export interface KnownQueries {
-}
-export interface KnownFileQueries {
-}
-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 { BunClient } from "./bun-runtime.js";
-export type TypedFile = TypedFileFor<KnownFileQueries>;
-export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
-export type Typed = TypedFor<KnownQueries, KnownFileQueries, import("./runtime.js").TransactionOptions>;
-export declare const sql: Typed;
-export type Unsafe = (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
-export declare const unsafe: Unsafe;
-export declare const getClient: typeof rt.getClient;
-export declare const setClient: typeof rt.setClient;
-export declare const close: typeof rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";