@onreza/sqlx-js 0.6.0 → 0.7.0

package/dist/src/commands/prepare.js

@@ -1,6 +1,6 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { PgClient, parseDatabaseUrl, PgError } from "../pg/wire.js";
 import { SchemaCache, compositeLiteral } from "../pg/schema.js";
 import { analyzeQuery } from "../pg/analyze.js";
@@ -9,7 +9,7 @@ import { ScanError, scanProject } from "../scan/scanner.js";
 import { assertCacheManifest, Cache, fingerprint, effectiveNullable, portableCacheOid, writeCacheManifest, } from "../cache.js";
 import { emitDts } from "../codegen.js";
 import { loadConfig, lookupJsonbType, prepareConfigHash } from "../config.js";
-import { readFunctionCache, writeFunctionCache } from "../function-cache.js";
+import { functionCacheExists, readFunctionCache, writeFunctionCache } from "../function-cache.js";
 import { introspectFunctions } from "../pg/functions.js";
 import { buildParamMap } from "../pg/param-map.js";
 import { mergeExtensionTypes } from "../pg/extensions.js";
@@ -71,7 +71,8 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
         const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
-            const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
+            const table = resolvedTargetTable(target, schema);
+            const decl = column && table ? lookupJsonbType(cfg, table.schema, table.name, column) : undefined;
             if (decl)
                 return jsonParameter(decl);
         }
@@ -81,7 +82,8 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
         const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
-            const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
+            const table = resolvedTargetTable(target, schema);
+            const decl = column && table ? lookupJsonbType(cfg, table.schema, table.name, column) : undefined;
             if (decl)
                 return arrayParameter(jsonParameter(decl));
         }
@@ -103,6 +105,10 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
     }
     return resolveTs(paramOid, (oid) => schema.customType(oid));
 }
+function resolvedTargetTable(target, schema) {
+    const oid = schema.resolveTable(target.schema, target.table);
+    return oid === undefined ? undefined : schema.tableNameByOid(oid);
+}
 function resolveTargetColumn(target, schema) {
     if (target.column)
         return target.column;
@@ -301,17 +307,23 @@ export async function describeAll(cfg, sessionClient, queries, concurrency) {
     }
     return results;
 }
-export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency()) {
+export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency(), input = {}) {
     let sites;
-    try {
-        sites = scanProject(opts.root, session.userCfg.scan);
+    if (input.sites) {
+        sites = input.sites;
     }
-    catch (error) {
-        throw fatal("scan", error);
+    else {
+        try {
+            sites = scanProject(opts.root, session.userCfg.scan);
+        }
+        catch (error) {
+            throw fatal("scan", error);
+        }
     }
     log(`scanned: found ${sites.length} sql() call site(s)`);
     const diagnostics = [];
     const cache = new Cache(opts.cacheDir);
+    let failures = 0;
     const unique = new Map();
     for (const s of sites) {
         const fp = fingerprint(s.query);
@@ -322,11 +334,30 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             unique.set(fp, { fp, query: s.query, sites: [s] });
     }
     const raw = [];
-    let failures = 0;
+    const reusedEntries = [];
+    const reusedGenerated = [];
     const { client, schema, userCfg } = session;
-    const describeList = [...unique.values()].map((u) => ({ fp: u.fp, query: u.query }));
+    const toPrepare = new Map();
+    for (const [fp, item] of unique) {
+        const cached = input.reuseCacheFps?.has(fp) ? cache.read(fp) : null;
+        if (!cached) {
+            toPrepare.set(fp, item);
+            continue;
+        }
+        const entry = { ...cached, ...siteUsage(item.sites) };
+        const entryDiagnostics = inferenceDiagnostics(entry, item.sites[0], opts.strictInference === true);
+        diagnostics.push(...entryDiagnostics);
+        if (opts.strictInference && entryDiagnostics.length > 0) {
+            failures++;
+            continue;
+        }
+        reusedEntries.push(entry);
+        reusedGenerated.push({ fp, entry });
+        log(`  ↺ ${formatSite(item.sites[0])} → reused ${entry.paramOids.length} param(s), ${entry.columns.length} col(s)`);
+    }
+    const describeList = [...toPrepare.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()) {
+    for (const { fp, query, sites: ss } of toPrepare.values()) {
         const site = ss[0];
         const outcome = describeResults.get(fp);
         if (outcome.ok) {
@@ -455,8 +486,8 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         for (const idx of pm.dmlBound) {
             const t = pm.targets.get(idx);
             if (t) {
-                const schema = t.schema ?? "public";
-                dmlTablesToLoad.set(JSON.stringify([schema, t.table]), { schema, name: t.table });
+                const key = JSON.stringify([t.schema ?? null, t.table]);
+                dmlTablesToLoad.set(key, t.schema ? { schema: t.schema, name: t.table } : { name: t.table });
             }
         }
     }
@@ -491,8 +522,8 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
     catch (error) {
         throw fatal("introspect", error);
     }
-    const entries = [];
-    const generated = [];
+    const entries = [...reusedEntries];
+    const generated = [...reusedGenerated];
     for (const r of raw) {
         if (failedFps.has(r.fp))
             continue;
@@ -544,11 +575,16 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         return { sites: sites.length, entries: entries.length, failures, pruned: 0, functions: 0, diagnostics };
     }
     let functions;
-    try {
-        functions = await introspectFunctions(client, schema);
+    if (input.reuseFunctions && functionCacheExists(opts.cacheDir)) {
+        functions = readFunctionCache(opts.cacheDir);
     }
-    catch (error) {
-        throw fatal("introspect", error);
+    else {
+        try {
+            functions = await introspectFunctions(client, schema);
+        }
+        catch (error) {
+            throw fatal("introspect", error);
+        }
     }
     let pruned;
     try {
@@ -580,7 +616,8 @@ export async function runPrepare(opts) {
             process.exitCode = 1;
         return;
     }
-    if (opts.check) {
+    if (opts.check || opts.offline) {
+        const mode = opts.offline ? "offline" : "check";
         let userCfg;
         try {
             userCfg = await loadConfig(opts.root);
@@ -637,9 +674,9 @@ export async function runPrepare(opts) {
                 console.log(JSON.stringify({
                     formatVersion: 1,
                     ok: false,
-                    mode: "check",
+                    mode,
                     sites: sites.length,
-                    entries: unique.size - diagnostics.length,
+                    entries: [...unique.keys()].filter((fp) => cache.has(fp)).length,
                     failures: diagnostics.length,
                     pruned: 0,
                     functions: 0,
@@ -647,7 +684,7 @@ export async function runPrepare(opts) {
                 }, null, 2));
             }
             else {
-                console.error(`\nsqlx-js prepare --check: ${diagnostics.length} stale/missing entries. Run \`sqlx-js prepare\` against a live DB.`);
+                console.error(`\nsqlx-js prepare --${mode}: ${diagnostics.length} stale/missing entries. Run \`sqlx-js prepare\` against a live DB.`);
             }
             process.exitCode = 1;
             return;
@@ -670,12 +707,39 @@ export async function runPrepare(opts) {
                 entries.push(current);
             }
             functions = readFunctionCache(opts.cacheDir);
+            if (!functionCacheExists(opts.cacheDir)) {
+                diagnostics.push({
+                    severity: "error",
+                    phase: "cache",
+                    message: "function cache is missing",
+                });
+                inferenceFailures++;
+            }
+            if (opts.check && inferenceFailures === 0) {
+                const tmp = mkdtempSync(join(tmpdir(), "sqlx-js-check-"));
+                const generatedDts = join(tmp, "sqlx-js-env.d.ts");
+                try {
+                    emitDts(generatedDts, entries, functions);
+                    if (!existsSync(opts.dtsPath) || readFileSync(opts.dtsPath, "utf8") !== readFileSync(generatedDts, "utf8")) {
+                        diagnostics.push({
+                            severity: "error",
+                            phase: "cache",
+                            message: "generated declaration is stale or missing",
+                            file: relative(opts.root, opts.dtsPath).replace(/\\/g, "/"),
+                        });
+                        inferenceFailures++;
+                    }
+                }
+                finally {
+                    rmSync(tmp, { recursive: true, force: true });
+                }
+            }
             if (inferenceFailures > 0) {
                 if (opts.json) {
                     console.log(JSON.stringify({
                         formatVersion: 1,
                         ok: false,
-                        mode: "check",
+                        mode,
                         sites: sites.length,
                         entries: entries.length,
                         failures: inferenceFailures,
@@ -686,13 +750,17 @@ export async function runPrepare(opts) {
                 }
                 else {
                     for (const diagnostic of diagnostics) {
-                        console.error(`inference failed: ${diagnostic.file}:${diagnostic.line}:${diagnostic.column} — ${diagnostic.message}`);
+                        const location = diagnostic.file
+                            ? `${diagnostic.file}${diagnostic.line ? `:${diagnostic.line}:${diagnostic.column ?? 1}` : ""} — `
+                            : "";
+                        console.error(`${diagnostic.phase} failed: ${location}${diagnostic.message}`);
                     }
                 }
                 process.exitCode = 1;
                 return;
             }
-            emitDts(opts.dtsPath, entries, functions);
+            if (opts.offline)
+                emitDts(opts.dtsPath, entries, functions);
         }
         catch (error) {
             throw fatal("cache", error);
@@ -701,7 +769,7 @@ export async function runPrepare(opts) {
             console.log(JSON.stringify({
                 formatVersion: 1,
                 ok: true,
-                mode: "check",
+                mode,
                 sites: sites.length,
                 entries: entries.length,
                 failures: 0,
@@ -714,7 +782,8 @@ export async function runPrepare(opts) {
             for (const diagnostic of diagnostics) {
                 console.error(`inference warning: ${diagnostic.file}:${diagnostic.line}:${diagnostic.column} — ${diagnostic.message}`);
             }
-            console.log(`ok — ${entries.length} unique queries, ${functions.length} function(s), types regenerated`);
+            const suffix = opts.offline ? ", types regenerated" : ", generated artifacts are current";
+            console.log(`ok — ${entries.length} unique queries, ${functions.length} function(s)${suffix}`);
         }
         return;
     }

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

@@ -1,22 +1,30 @@
-import { openSession, prepareOnce, type PrepareOptions, type PrepareSession } from "./prepare.js";
+import { openSession, prepareOnce, type PrepareOptions, type PrepareResult, type PrepareSession } from "./prepare.js";
+import { loadConfig } from "../config.js";
+import { findSourceFiles, scanFile, scanProject, type QueryCallSite } from "../scan/scanner.js";
 export declare function shouldWatchFile(filename: string): boolean;
 export type WatchPrepareHookResult = {
     resetSession?: boolean;
 };
 export type WatchOptions = PrepareOptions & {
     beforePrepare?: () => Promise<WatchPrepareHookResult | void>;
+    jsonl?: boolean;
 };
 export type WatchState = {
     session: PrepareSession | null;
+    sitesByFile?: Map<string, QueryCallSite[]>;
+    dirtyFiles?: Set<string>;
+    dirtyFps?: Set<string>;
 };
+export declare function formatWatchEvent(name: string, data?: Record<string, unknown>, timestamp?: string): string;
+export declare function watchErrorData(error: unknown): Record<string, unknown>;
 type WatchDeps = {
     openSession: typeof openSession;
     prepareOnce: typeof prepareOnce;
+    loadConfig: typeof loadConfig;
+    scanProject: typeof scanProject;
+    scanFile: typeof scanFile;
+    findSourceFiles: typeof findSourceFiles;
 };
-export declare function prepareWatchedOnce(opts: WatchOptions, state: WatchState, log: (msg: string) => void, err: (msg: string) => void, deps?: WatchDeps): Promise<{
-    entries: number;
-    failures: number;
-    pruned: number;
-}>;
+export declare function prepareWatchedOnce(opts: WatchOptions, state: WatchState, log: (msg: string) => void, err: (msg: string) => void, deps?: Partial<WatchDeps>, changedFiles?: readonly string[]): Promise<PrepareResult>;
 export declare function runWatch(opts: WatchOptions): Promise<void>;
 export {};

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;