@onreza/sqlx-js 0.6.0 → 0.8.0

package/dist/src/commands/watch.js

@@ -1,7 +1,9 @@
-import { watch as fsWatch } from "node:fs";
-import { basename } from "node:path";
-import { openSession, prepareOnce } from "./prepare.js";
+import { existsSync, watch as fsWatch } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { openSession, prepareOnce, PrepareFatalError, } from "./prepare.js";
 import { configHash, loadConfig } from "../config.js";
+import { fingerprint } from "../cache.js";
+import { findSourceFiles, scanFile, scanProject } from "../scan/scanner.js";
 const EXT_RE = /\.(ts|tsx|mts|cts|sql)$/;
 const SKIP_DIRS = ["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"];
 const DEBOUNCE_MS = 150;
@@ -23,7 +25,25 @@ export function shouldWatchFile(filename) {
         return true;
     return EXT_RE.test(file);
 }
-const DEFAULT_DEPS = { openSession, prepareOnce };
+export function formatWatchEvent(name, data = {}, timestamp = new Date().toISOString()) {
+    return JSON.stringify({ formatVersion: 1, event: name, timestamp, ...data });
+}
+export function watchErrorData(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!(error instanceof PrepareFatalError))
+        return { message };
+    return {
+        diagnostic: {
+            severity: "error",
+            phase: error.phase,
+            message,
+            ...(error.file === undefined ? {} : { file: error.file }),
+            ...(error.line === undefined ? {} : { line: error.line }),
+            ...(error.column === undefined ? {} : { column: error.column }),
+        },
+    };
+}
+const DEFAULT_DEPS = { openSession, prepareOnce, loadConfig, scanProject, scanFile, findSourceFiles };
 async function closeSession(session) {
     if (!session)
         return;
@@ -32,35 +52,164 @@ async function closeSession(session) {
     }
     catch { }
 }
-export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_DEPS) {
+export async function prepareWatchedOnce(opts, state, log, err, deps = {}, changedFiles = []) {
+    const active = { ...DEFAULT_DEPS, ...deps };
     const hookResult = await opts.beforePrepare?.();
-    const currentConfig = await loadConfig(opts.root);
-    if (hookResult?.resetSession === true ||
-        (state.session !== null && configHash(state.session.userCfg) !== configHash(currentConfig))) {
+    const currentConfig = await active.loadConfig(opts.root);
+    const configChanged = state.session !== null && configHash(state.session.userCfg) !== configHash(currentConfig);
+    const resetSession = hookResult?.resetSession === true || configChanged;
+    if (resetSession) {
         await closeSession(state.session);
         state.session = null;
     }
     if (!state.session)
-        state.session = await deps.openSession(opts);
-    return await deps.prepareOnce(opts, state.session, log, err, 1);
+        state.session = await active.openSession(opts);
+    const full = resetSession || !state.sitesByFile || changedFiles.some(isProjectGraphFile);
+    let nextSites;
+    let changedFps = new Set();
+    if (full) {
+        const sites = active.scanProject(opts.root, currentConfig.scan);
+        nextSites = groupSites(sites);
+        changedFps = new Set(sites.map((site) => fingerprint(site.query)));
+    }
+    else {
+        const previousSites = state.sitesByFile;
+        const dirtyFiles = state.dirtyFiles ?? new Set();
+        const requested = new Set([...changedFiles, ...dirtyFiles].map((file) => projectPath(opts.root, file)));
+        const affectedSources = new Set();
+        for (const changed of requested) {
+            if (/\.(ts|tsx|mts|cts)$/.test(changed))
+                affectedSources.add(changed);
+            if (changed.endsWith(".sql")) {
+                for (const [source, sites] of previousSites) {
+                    if (sites.some((site) => site.sqlFilePath && projectPath(opts.root, site.sqlFilePath) === changed)) {
+                        affectedSources.add(source);
+                    }
+                }
+            }
+        }
+        nextSites = new Map(previousSites);
+        const allowed = new Set(active.findSourceFiles(opts.root, currentConfig.scan).map((file) => projectPath(opts.root, file)));
+        for (const source of nextSites.keys()) {
+            if (!allowed.has(source))
+                affectedSources.add(source);
+        }
+        try {
+            for (const source of affectedSources) {
+                const previous = nextSites.get(source) ?? [];
+                for (const site of previous)
+                    changedFps.add(fingerprint(site.query));
+                const absolute = resolve(opts.root, source);
+                if (!existsSync(absolute) || !allowed.has(source)) {
+                    nextSites.delete(source);
+                    continue;
+                }
+                const scanned = active.scanFile(absolute, opts.root, currentConfig.scan?.modules);
+                if (scanned.length > 0)
+                    nextSites.set(source, scanned);
+                else
+                    nextSites.delete(source);
+                for (const site of scanned)
+                    changedFps.add(fingerprint(site.query));
+            }
+            for (const source of affectedSources)
+                dirtyFiles.delete(source);
+        }
+        catch (error) {
+            for (const source of affectedSources)
+                dirtyFiles.add(source);
+            state.dirtyFiles = dirtyFiles;
+            throw error;
+        }
+        state.dirtyFiles = dirtyFiles;
+    }
+    const sites = [...nextSites.values()].flat();
+    const dirtyFps = state.dirtyFps ?? new Set();
+    const reuseCacheFps = new Set(sites
+        .map((site) => fingerprint(site.query))
+        .filter((fp) => !changedFps.has(fp) && !dirtyFps.has(fp)));
+    const result = await active.prepareOnce(opts, state.session, log, err, 1, {
+        sites,
+        reuseCacheFps,
+        reuseFunctions: !full,
+    });
+    state.sitesByFile = nextSites;
+    if (result.failures === 0) {
+        state.dirtyFps = new Set();
+    }
+    else {
+        state.dirtyFps = new Set([...dirtyFps, ...changedFps]);
+    }
+    return result;
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function projectPath(root, path) {
+    return normalizePath(relative(resolve(root), resolve(root, path)));
+}
+function isProjectGraphFile(path) {
+    const base = basename(path);
+    return CONFIG_FILES.has(base) || /^tsconfig(?:\.[^.]+)*\.json$/.test(base);
+}
+function groupSites(sites) {
+    const grouped = new Map();
+    for (const site of sites) {
+        const file = normalizePath(site.file);
+        const current = grouped.get(file) ?? [];
+        current.push(site);
+        grouped.set(file, current);
+    }
+    return grouped;
 }
 export async function runWatch(opts) {
     const stamp = () => new Date().toTimeString().slice(0, 8);
-    const log = (m) => console.log(`[${stamp()}] ${m}`);
-    const err = (m) => console.error(`[${stamp()}] ${m}`);
+    const event = (name, data = {}) => {
+        console.log(formatWatchEvent(name, data));
+    };
+    const log = opts.jsonl ? () => { } : (m) => console.log(`[${stamp()}] ${m}`);
+    const err = opts.jsonl ? () => { } : (m) => console.error(`[${stamp()}] ${m}`);
     const state = { session: null };
-    log("watch: initial prepare");
+    const report = (result, durationMs) => {
+        if (!opts.jsonl)
+            return;
+        for (const diagnostic of result.diagnostics)
+            event("diagnostic", { diagnostic });
+        event("prepared", {
+            ok: result.failures === 0,
+            sites: result.sites,
+            entries: result.entries,
+            failures: result.failures,
+            pruned: result.pruned,
+            functions: result.functions,
+            ...(durationMs === undefined ? {} : { durationMs }),
+        });
+    };
+    if (opts.jsonl)
+        event("start", { root: opts.root });
+    else
+        log("watch: initial prepare");
     try {
         const r = await prepareWatchedOnce(opts, state, log, err);
-        log(`watch: ready — ${r.entries} queries, ${r.failures} failures`);
+        if (opts.jsonl)
+            report(r);
+        else
+            log(`watch: ready — ${r.entries} queries, ${r.failures} failures`);
     }
     catch (e) {
-        err(`watch: initial prepare failed — ${e.message}`);
+        if (opts.jsonl)
+            event("error", watchErrorData(e));
+        else
+            err(`watch: initial prepare failed — ${e.message}`);
     }
-    log(`watch: monitoring ${opts.root}`);
+    if (opts.jsonl)
+        event("watching", { root: opts.root });
+    else
+        log(`watch: monitoring ${opts.root}`);
     let pending = false;
     let running = null;
     let timer = null;
+    const changedFiles = new Set();
     const trigger = () => {
         if (timer)
             clearTimeout(timer);
@@ -71,13 +220,22 @@ export async function runWatch(opts) {
                 return;
             }
             const start = Date.now();
+            const batch = [...changedFiles];
+            changedFiles.clear();
             running = (async () => {
                 try {
-                    const r = await prepareWatchedOnce(opts, state, log, err);
-                    log(`watch: re-prepared in ${Date.now() - start}ms (${r.entries} queries, ${r.failures} failures)`);
+                    const r = await prepareWatchedOnce(opts, state, log, err, {}, batch);
+                    const durationMs = Date.now() - start;
+                    if (opts.jsonl)
+                        report(r, durationMs);
+                    else
+                        log(`watch: re-prepared in ${durationMs}ms (${r.entries} queries, ${r.failures} failures)`);
                 }
                 catch (e) {
-                    err(`watch: prepare error — ${e.message}`);
+                    if (opts.jsonl)
+                        event("error", watchErrorData(e));
+                    else
+                        err(`watch: prepare error — ${e.message}`);
                 }
             })();
             await running;
@@ -93,11 +251,16 @@ export async function runWatch(opts) {
             return;
         if (!shouldWatchFile(filename.toString()))
             return;
+        changedFiles.add(normalizePath(filename.toString()));
         trigger();
     });
     const shutdown = async () => {
-        console.log();
-        log("watch: stopping");
+        if (opts.jsonl)
+            event("stopping");
+        else {
+            console.log();
+            log("watch: stopping");
+        }
         watcher.close();
         await closeSession(state.session);
         process.exit(0);

package/dist/src/function-cache.d.ts

@@ -14,5 +14,7 @@ export type FunctionEntry = {
     returns: string;
     returnsSet: boolean;
 };
+export declare function functionCachePath(cacheDir: string): string;
+export declare function functionCacheExists(cacheDir: string): boolean;
 export declare function readFunctionCache(cacheDir: string): FunctionEntry[];
 export declare function writeFunctionCache(cacheDir: string, functions: FunctionEntry[]): void;

package/dist/src/function-cache.js

@@ -1,9 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
-function cachePath(cacheDir) {
+export function functionCachePath(cacheDir) {
     return join(cacheDir, "functions", "functions.json");
 }
+export function functionCacheExists(cacheDir) {
+    return existsSync(functionCachePath(cacheDir));
+}
 function parseFunctionCache(raw) {
     if (!raw || typeof raw !== "object")
         return [];
@@ -13,14 +16,14 @@ function parseFunctionCache(raw) {
     return obj.functions;
 }
 export function readFunctionCache(cacheDir) {
-    const path = cachePath(cacheDir);
+    const path = functionCachePath(cacheDir);
     if (!existsSync(path))
         return [];
     const text = readFileSync(path, "utf8");
     return parseFunctionCache(JSON.parse(text));
 }
 export function writeFunctionCache(cacheDir, functions) {
-    const path = cachePath(cacheDir);
+    const path = functionCachePath(cacheDir);
     mkdirSync(dirname(path), { recursive: true });
     const payload = { version: 1, functions };
     const tmp = `${path}.tmp-${randomBytes(4).toString("hex")}`;

package/dist/src/index.d.ts

@@ -23,17 +23,33 @@ export type { ScanConfig, 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, OnQueryEvent, OnQueryHook } from "./runtime.js";
+export type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook, OnQueryHookError } from "./runtime.js";
 export type { ExecuteResult, JsonParameter, PgArrayParameter } 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>;
+export type QueryRegistry = {
+    queries: object;
+    fileQueries: object;
+};
+export interface DefaultQueryRegistry {
+    queries: KnownQueries;
+    fileQueries: KnownFileQueries;
+    functions: KnownFunctions;
+}
+export type SqlClient<Registry extends QueryRegistry = DefaultQueryRegistry> = {
+    sql: TypedFor<Registry["queries"], Registry["fileQueries"], import("./runtime.js").TransactionOptions>;
+    unsafe: Unsafe;
+    client: import("./postgres-runtime.js").PostgresClient;
+    close: () => Promise<void>;
+};
 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 createClient: typeof rt.createClient;
+export declare function createSqlClient<Registry extends QueryRegistry = DefaultQueryRegistry>(url?: string, options?: import("./postgres-runtime.js").CreateClientOptions): SqlClient<Registry>;
 export declare const close: typeof rt.close;
 export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

package/dist/src/index.js

@@ -7,5 +7,8 @@ export const unsafe = rt.unsafe;
 export const getClient = rt.getClient;
 export const setClient = rt.setClient;
 export const createClient = rt.createClient;
+export function createSqlClient(url, options) {
+    return rt.createSqlClient(url, options);
+}
 export const close = rt.close;
 export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

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

@@ -68,6 +68,7 @@ export declare class SchemaCache {
         name: string;
     } | undefined;
     loadTableNamesByOid(oids: number[]): Promise<void>;
+    private recordTable;
     columnNameByAttno(tableOid: number, attno: number): string | undefined;
     loadColumnsForTables(tableOids: number[]): Promise<void>;
     columnsOf(tableOid: number): Map<string, ColumnInfo> | undefined;

package/dist/src/pg/schema.js

@@ -49,34 +49,38 @@ export class SchemaCache {
         }
     }
     async loadTableNames(names) {
-        const need = [];
+        const explicit = [];
+        const visible = [];
         for (const n of names) {
-            const schema = n.schema ?? "public";
-            const key = `${schema}.${n.name}`;
-            if (!this.nameToOid.has(key))
-                need.push({ schema, name: n.name });
+            if (n.schema) {
+                if (!this.nameToOid.has(`${n.schema}.${n.name}`))
+                    explicit.push({ schema: n.schema, name: n.name });
+            }
+            else if (!this.nameToOid.has(unqualifiedKey(n.name))) {
+                visible.push(n.name);
+            }
         }
-        if (need.length === 0)
-            return;
-        const where = need.map((n) => `(n.nspname = ${quote(n.schema)} AND c.relname = ${quote(n.name)})`).join(" OR ");
-        const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE ${where}`;
-        const r = await this.client.simpleQueryAll(sql);
-        for (const row of r.rows) {
-            const oid = Number(decodeText(row[0]));
-            const schema = decodeText(row[1]);
-            const name = decodeText(row[2]);
-            const k = `${schema}.${name}`;
-            const arr = this.nameToOid.get(k) ?? [];
-            arr.push(oid);
-            this.nameToOid.set(k, arr);
-            this.oidToName.set(oid, { schema, name });
+        if (explicit.length > 0) {
+            const where = explicit.map((n) => `(n.nspname = ${quote(n.schema)} AND c.relname = ${quote(n.name)})`).join(" OR ");
+            const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE ${where}`;
+            const result = await this.client.simpleQueryAll(sql);
+            for (const row of result.rows)
+                this.recordTable(row);
+        }
+        if (visible.length > 0) {
+            const requested = [...new Set(visible)].map(quote).join(",");
+            const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.relname IN (${requested}) AND pg_table_is_visible(c.oid)`;
+            const result = await this.client.simpleQueryAll(sql);
+            for (const row of result.rows) {
+                this.recordTable(row, true);
+            }
         }
     }
     isNotNull(tableOid, attno) {
         return this.byOidNum.get(key(tableOid, attno))?.notNull;
     }
     resolveTable(schema, name) {
-        const k = `${schema ?? "public"}.${name}`;
+        const k = schema ? `${schema}.${name}` : unqualifiedKey(name);
         const arr = this.nameToOid.get(k);
         return arr?.[0];
     }
@@ -89,17 +93,21 @@ export class SchemaCache {
             return;
         const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.oid IN (${need.join(",")})`;
         const r = await this.client.simpleQueryAll(sql);
-        for (const row of r.rows) {
-            const oid = Number(decodeText(row[0]));
-            const schema = decodeText(row[1]);
-            const name = decodeText(row[2]);
-            const k = `${schema}.${name}`;
-            const arr = this.nameToOid.get(k) ?? [];
-            if (!arr.includes(oid))
-                arr.push(oid);
-            this.nameToOid.set(k, arr);
-            this.oidToName.set(oid, { schema, name });
-        }
+        for (const row of r.rows)
+            this.recordTable(row);
+    }
+    recordTable(row, visible = false) {
+        const oid = Number(decodeText(row[0]));
+        const schema = decodeText(row[1]);
+        const name = decodeText(row[2]);
+        const key = `${schema}.${name}`;
+        const arr = this.nameToOid.get(key) ?? [];
+        if (!arr.includes(oid))
+            arr.push(oid);
+        this.nameToOid.set(key, arr);
+        if (visible)
+            this.nameToOid.set(unqualifiedKey(name), [oid]);
+        this.oidToName.set(oid, { schema, name });
     }
     columnNameByAttno(tableOid, attno) {
         return this.byOidNum.get(key(tableOid, attno))?.name;
@@ -269,6 +277,9 @@ export class SchemaCache {
 function key(oid, attno) {
     return `${oid}/${attno}`;
 }
+function unqualifiedKey(name) {
+    return `\0${name}`;
+}
 function quote(s) {
     return `'${s.replace(/'/g, "''")}'`;
 }

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

@@ -8,6 +8,7 @@ export type ConnConfig = {
     database: string;
     sslmode?: SslMode;
     applicationName?: string;
+    startupOptions?: string;
     connectTimeoutMs?: number;
     statementTimeoutMs?: number;
     sslRootCert?: string;

package/dist/src/pg/wire.js

@@ -26,6 +26,9 @@ export function parseDatabaseUrl(url) {
     const appName = params.get("application_name");
     if (appName)
         cfg.applicationName = appName;
+    const startupOptions = params.get("options");
+    if (startupOptions)
+        cfg.startupOptions = startupOptions;
     const ct = params.get("connect_timeout");
     if (ct) {
         const n = Number(ct);
@@ -446,6 +449,9 @@ export class PgClient {
         if (this.cfg.applicationName) {
             pairs.push(cstr("application_name"), cstr(this.cfg.applicationName));
         }
+        if (this.cfg.startupOptions) {
+            pairs.push(cstr("options"), cstr(this.cfg.startupOptions));
+        }
         if (this.cfg.statementTimeoutMs !== undefined) {
             pairs.push(cstr("statement_timeout"), cstr(String(this.cfg.statementTimeoutMs)));
         }

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

@@ -1,21 +1,31 @@
 import postgres from "postgres";
-import { type OnQueryHook } from "./runtime.js";
+import { type OnQueryHook, type OnQueryHookError } from "./runtime.js";
 export type PostgresClient = postgres.Sql<{
     bigint: bigint;
 }>;
 export type PostgresOptions = postgres.Options<Record<string, postgres.PostgresType>>;
 export type CreateClientOptions = PostgresOptions & {
     onQuery?: OnQueryHook;
+    onQueryHookError?: OnQueryHookError;
     statementTimeoutMs?: number;
     fileRoot?: string;
+    reloadSqlFiles?: boolean;
 };
 export declare function createClient(url?: string | undefined, options?: CreateClientOptions): PostgresClient;
 export declare function getClient(): PostgresClient;
 export declare function setClient(client: PostgresClient, options?: {
     onQuery?: OnQueryHook;
+    onQueryHookError?: OnQueryHookError;
     prepare?: boolean;
     fileRoot?: string;
+    reloadSqlFiles?: boolean;
 }): void;
 export declare function close(): Promise<void>;
+export declare function createSqlClient(url?: string | undefined, options?: CreateClientOptions): {
+    client: PostgresClient;
+    close: () => Promise<void>;
+    sql: import("./runtime.js").SqlRoot;
+    unsafe: (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
+};
 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

@@ -9,13 +9,17 @@ function resolvedFileRoot(value) {
 class PostgresRuntimeClient {
     client;
     onQuery;
+    onQueryHookError;
     prepare;
     fileRoot;
-    constructor(client, onQuery, prepare = true, fileRoot = resolvedFileRoot()) {
+    reloadSqlFiles;
+    constructor(client, onQuery, onQueryHookError, prepare = true, fileRoot = resolvedFileRoot(), reloadSqlFiles = false) {
         this.client = client;
         this.onQuery = onQuery;
+        this.onQueryHookError = onQueryHookError;
         this.prepare = prepare;
         this.fileRoot = fileRoot;
+        this.reloadSqlFiles = reloadSqlFiles;
     }
     async query(query, params) {
         return await this.client.unsafe(query, params, { prepare: this.prepare });
@@ -39,7 +43,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, this.onQuery, this.prepare, this.fileRoot));
+            return await fn(new PostgresRuntimeClient(tx, this.onQuery, this.onQueryHookError, this.prepare, this.fileRoot, this.reloadSqlFiles));
         });
     }
     async close() {
@@ -158,7 +162,7 @@ function installJsonArrayCodecs(client) {
 export function createClient(url = process.env.DATABASE_URL, options = {}) {
     if (!url)
         throw new Error("sqlx-js: DATABASE_URL is not set");
-    const { onQuery, statementTimeoutMs, fileRoot, ...pgOptions } = options;
+    const { onQuery, onQueryHookError, statementTimeoutMs, fileRoot, reloadSqlFiles, ...pgOptions } = options;
     const connection = statementTimeoutMs !== undefined
         ? { ...(pgOptions.connection ?? {}), statement_timeout: statementTimeoutMs }
         : pgOptions.connection;
@@ -169,15 +173,17 @@ export function createClient(url = process.env.DATABASE_URL, options = {}) {
     });
     client[HOOKS] = {
         onQuery,
+        onQueryHookError,
         prepare: pgOptions.prepare ?? true,
         fileRoot: resolvedFileRoot(fileRoot),
+        reloadSqlFiles: reloadSqlFiles ?? false,
     };
     return client;
 }
 function createDefaultClient() {
     const client = createClient();
     const attached = client[HOOKS];
-    return new PostgresRuntimeClient(client, attached.onQuery, attached.prepare, attached.fileRoot);
+    return new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles);
 }
 function getRuntimeClient() {
     defaultClient ??= createDefaultClient();
@@ -189,7 +195,7 @@ export function getClient() {
 export function setClient(client, options) {
     installJsonArrayCodecs(client);
     const attached = client[HOOKS];
-    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery, options?.prepare ?? attached?.prepare ?? client.options?.prepare ?? true, resolvedFileRoot(options?.fileRoot ?? attached?.fileRoot));
+    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery, options?.onQueryHookError ?? attached?.onQueryHookError, options?.prepare ?? attached?.prepare ?? client.options?.prepare ?? true, resolvedFileRoot(options?.fileRoot ?? attached?.fileRoot), options?.reloadSqlFiles ?? attached?.reloadSqlFiles ?? false);
 }
 export async function close() {
     if (defaultClient) {
@@ -197,6 +203,17 @@ export async function close() {
         defaultClient = null;
     }
 }
+export function createSqlClient(url = process.env.DATABASE_URL, options = {}) {
+    const client = createClient(url, options);
+    const attached = client[HOOKS];
+    const runtimeClient = new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles);
+    const runtime = createSqlRuntime(() => runtimeClient);
+    return {
+        ...runtime,
+        client,
+        close: async () => runtimeClient.close(),
+    };
+}
 const runtime = createSqlRuntime(getRuntimeClient);
 export const sql = runtime.sql;
 export const unsafe = runtime.unsafe;

package/dist/src/runtime.d.ts

@@ -6,7 +6,8 @@ export type OnQueryEvent = {
     rowCount?: number;
     error?: unknown;
 };
-export type OnQueryHook = (event: OnQueryEvent) => void;
+export type OnQueryHook = (event: OnQueryEvent) => void | Promise<void>;
+export type OnQueryHookError = (error: unknown, event: OnQueryEvent) => void | Promise<void>;
 export type RuntimeQueryResult = unknown[] & {
     count?: number | null;
     command?: string | null;
@@ -17,7 +18,9 @@ export type RuntimeClient = {
     transaction: <R>(fn: (client: RuntimeClient) => Promise<R>) => Promise<R>;
     close: () => Promise<void>;
     onQuery?: OnQueryHook;
+    onQueryHookError?: OnQueryHookError;
     fileRoot?: string;
+    reloadSqlFiles?: boolean;
 };
 type AnyFn = (...args: unknown[]) => Promise<unknown[]>;
 type AnyOneFn = (...args: unknown[]) => Promise<unknown>;
@@ -71,7 +74,7 @@ export declare const _internal: {
     parameterKind: typeof parameterKind;
     toPgError: typeof toPgError;
 };
-declare function loadSqlFile(path: string, fileRoot?: string): string;
+declare function loadSqlFile(path: string, fileRoot?: string, reload?: boolean): string;
 export declare function clearSqlFileCache(): void;
 declare function clearIdentifierCache(): void;
 export declare function id(...parts: string[]): string;