@onreza/sqlx-js 0.3.0 → 0.5.0

package/dist/src/commands/prepare.js

@@ -1,16 +1,28 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { PgClient, parseDatabaseUrl, PgError } from "../pg/wire.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";
-import { Cache, fingerprint, effectiveNullable } from "../cache.js";
+import { arrayElementOid, isBuiltinOid, oidToTs } from "../pg/oids.js";
+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 } from "../config.js";
+import { loadConfig, lookupJsonbType, prepareConfigHash } from "../config.js";
+import { 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";
+import { compareArtifacts } from "../artifacts.js";
 const JSON_OIDS = new Set([114, 3802]);
 const JSON_ARRAY_OIDS = new Set([199, 3807]);
-const JSON_INPUT = 'import("@onreza/sqlx-js").JsonInput';
+const JSON_INPUT_VALUE = 'import("@onreza/sqlx-js").JsonInputValue';
+function jsonParameter(type) {
+    return `import("@onreza/sqlx-js").JsonParameter<${type}>`;
+}
+function arrayParameter(type) {
+    return `import("@onreza/sqlx-js").PgArrayParameter<${type}>`;
+}
 function enumUnion(values) {
     if (values.length === 0)
         return "never";
@@ -54,15 +66,39 @@ function resolveColumnTs(f, schema, cfg) {
     return resolveTs(f.typeOid, (oid) => schema.customType(oid));
 }
 function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
-    if (JSON_OIDS.has(paramOid) || JSON_ARRAY_OIDS.has(paramOid)) {
+    if (JSON_OIDS.has(paramOid)) {
+        const target = paramMap.get(paramIndex);
+        if (target) {
+            const column = resolveTargetColumn(target, schema);
+            const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
+            if (decl)
+                return jsonParameter(decl);
+        }
+        return jsonParameter(JSON_INPUT_VALUE);
+    }
+    if (JSON_ARRAY_OIDS.has(paramOid)) {
         const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
             const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
             if (decl)
-                return JSON_ARRAY_OIDS.has(paramOid) ? `(${decl})[]` : decl;
+                return arrayParameter(jsonParameter(decl));
         }
-        return JSON_ARRAY_OIDS.has(paramOid) ? `(${JSON_INPUT})[]` : JSON_INPUT;
+        return arrayParameter(jsonParameter(JSON_INPUT_VALUE));
+    }
+    const builtinElementOid = arrayElementOid(paramOid);
+    if (builtinElementOid !== undefined) {
+        return arrayParameter(resolveTs(builtinElementOid, (oid) => schema.customType(oid)));
+    }
+    const custom = schema.customType(paramOid);
+    if (custom?.kind === "enumArray")
+        return arrayParameter(enumUnion(custom.element.values));
+    if (custom?.kind === "scalarArray")
+        return arrayParameter(custom.element.tsType);
+    if (custom?.kind === "compositeArray")
+        return arrayParameter(compositeLiteral(custom.element));
+    if (custom) {
+        return resolveTs(paramOid, () => custom);
     }
     return resolveTs(paramOid, (oid) => schema.customType(oid));
 }
@@ -112,6 +148,29 @@ function isAliasOrExpression(f, schema) {
     const real = schema.columnNameByAttno(f.tableOid, f.columnAttr);
     return real !== undefined && real !== f.name;
 }
+export class PrepareFatalError extends Error {
+    phase;
+    file;
+    line;
+    column;
+    constructor(phase, message, location = {}, options) {
+        super(message, options);
+        this.phase = phase;
+        this.name = "PrepareFatalError";
+        this.file = location.file;
+        this.line = location.line;
+        this.column = location.column;
+    }
+}
+function fatal(phase, error) {
+    if (error instanceof PrepareFatalError)
+        return error;
+    const message = error instanceof Error ? error.message : String(error);
+    const location = error instanceof ScanError
+        ? { file: error.file, line: error.line, column: error.column }
+        : {};
+    return new PrepareFatalError(phase, message, location, { cause: error });
+}
 function formatSite(s) {
     return `${s.file}:${s.line}:${s.column}`;
 }
@@ -129,10 +188,28 @@ function siteUsage(sites) {
     };
 }
 export async function openSession(opts) {
-    const userCfg = await loadConfig(opts.root);
-    const cfg = parseDatabaseUrl(opts.databaseUrl);
+    let userCfg;
+    try {
+        userCfg = await loadConfig(opts.root);
+    }
+    catch (error) {
+        throw fatal("config", error);
+    }
+    let cfg;
+    try {
+        cfg = parseDatabaseUrl(opts.databaseUrl);
+    }
+    catch (error) {
+        throw fatal("connect", error);
+    }
     const client = new PgClient(cfg);
-    await client.connect();
+    try {
+        await client.connect();
+    }
+    catch (error) {
+        await client.end().catch(() => { });
+        throw fatal("connect", error);
+    }
     const schema = new SchemaCache(client);
     schema.setTypeRegistry(mergeExtensionTypes(userCfg.customTypes));
     return { client, schema, userCfg };
@@ -190,8 +267,15 @@ export async function describeAll(cfg, sessionClient, queries, concurrency) {
     return results;
 }
 export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency()) {
-    const sites = scanProject(opts.root);
+    let sites;
+    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);
     const unique = new Map();
     for (const s of sites) {
@@ -217,6 +301,18 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         failures++;
         const e = outcome.error;
         if (e instanceof PgError) {
+            diagnostics.push({
+                severity: "error",
+                phase: "describe",
+                message: e.message,
+                file: site.file,
+                line: site.line,
+                column: site.column,
+                query,
+                ...(e.code ? { code: e.code } : {}),
+                ...(e.position ? { position: e.position } : {}),
+                ...(e.hint ? { hint: e.hint } : {}),
+            });
             const extras = [];
             if (e.position)
                 extras.push(`pos ${e.position}`);
@@ -229,6 +325,15 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             err(`      query: ${snippet(query)}`);
         }
         else {
+            diagnostics.push({
+                severity: "error",
+                phase: "describe",
+                message: e.message,
+                file: site.file,
+                line: site.line,
+                column: site.column,
+                query,
+            });
             err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
             err(`      query: ${snippet(query)}`);
         }
@@ -243,8 +348,13 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             }
         }
     }
-    await schema.loadAttributes(allAttrRefs);
-    await schema.loadTableNamesByOid(allTableOids);
+    try {
+        await schema.loadAttributes(allAttrRefs);
+        await schema.loadTableNamesByOid(allTableOids);
+    }
+    catch (error) {
+        throw fatal("introspect", error);
+    }
     const analyses = new Map();
     const paramMaps = new Map();
     const failedFps = new Set();
@@ -256,6 +366,15 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         catch (e) {
             failures++;
             failedFps.add(r.fp);
+            diagnostics.push({
+                severity: "error",
+                phase: "analyze",
+                message: e.message,
+                file: site.file,
+                line: site.line,
+                column: site.column,
+                query: r.query,
+            });
             err(`  ✗ ${formatSite(site)} — analyze failed: ${e.message}`);
             err(`      query: ${snippet(r.query)}`);
             continue;
@@ -266,31 +385,44 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         catch (e) {
             failures++;
             failedFps.add(r.fp);
+            diagnostics.push({
+                severity: "error",
+                phase: "param-map",
+                message: e.message,
+                file: site.file,
+                line: site.line,
+                column: site.column,
+                query: r.query,
+            });
             err(`  ✗ ${formatSite(site)} — paramMap failed: ${e.message}`);
             err(`      query: ${snippet(r.query)}`);
         }
     }
-    const dmlTablesToLoad = new Set();
+    const dmlTablesToLoad = new Map();
     for (const pm of paramMaps.values()) {
         for (const idx of pm.dmlBound) {
             const t = pm.targets.get(idx);
-            if (t)
-                dmlTablesToLoad.add(`${t.schema ?? "public"}.${t.table}`);
+            if (t) {
+                const schema = t.schema ?? "public";
+                dmlTablesToLoad.set(JSON.stringify([schema, t.table]), { schema, name: t.table });
+            }
         }
     }
-    if (dmlTablesToLoad.size > 0) {
-        const names = [...dmlTablesToLoad].map((k) => {
-            const [schema, name] = k.split(".");
-            return { schema, name: name };
-        });
-        await schema.loadTableNames(names);
-        const oids = [];
-        for (const n of names) {
-            const oid = schema.resolveTable(n.schema, n.name);
-            if (oid !== undefined)
-                oids.push(oid);
+    try {
+        if (dmlTablesToLoad.size > 0) {
+            const names = [...dmlTablesToLoad.values()];
+            await schema.loadTableNames(names);
+            const oids = [];
+            for (const n of names) {
+                const oid = schema.resolveTable(n.schema, n.name);
+                if (oid !== undefined)
+                    oids.push(oid);
+            }
+            await schema.loadColumnsForTables(oids);
         }
-        await schema.loadColumnsForTables(oids);
+    }
+    catch (error) {
+        throw fatal("introspect", error);
     }
     const unknownOids = new Set();
     for (const r of raw) {
@@ -301,8 +433,14 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             if (!isBuiltinOid(f.typeOid))
                 unknownOids.add(f.typeOid);
     }
-    await schema.loadCustomTypes([...unknownOids]);
+    try {
+        await schema.loadCustomTypes([...unknownOids]);
+    }
+    catch (error) {
+        throw fatal("introspect", error);
+    }
     const entries = [];
+    const generated = [];
     for (const r of raw) {
         if (failedFps.has(r.fp))
             continue;
@@ -315,7 +453,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         const entry = {
             query: r.query,
             ...siteUsage(r.sites),
-            paramOids: r.paramOids,
+            paramOids: r.paramOids.map(portableCacheOid),
             paramTsTypes: r.paramOids.map((o, idx) => resolveParamTs(idx + 1, o, pm.targets, schema, userCfg)),
             paramNullable: r.paramOids.map((_o, idx) => resolveParamNullable(idx + 1, pm, schema)),
             columns: r.fields.map((f, i) => {
@@ -323,7 +461,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 const treatAsOverride = parsed.override !== undefined && isAliasOrExpression(f, schema);
                 return {
                     name: parsed.name,
-                    typeOid: f.typeOid,
+                    typeOid: portableCacheOid(f.typeOid),
                     tsType: resolveColumnTs(f, schema, userCfg),
                     nullable: analysis.perColumnNullable[i] ?? true,
                     ...(treatAsOverride ? { override: parsed.override } : {}),
@@ -332,26 +470,76 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             hasResultSet: r.fields.length > 0,
             ...(analysis.degraded ? { degraded: analysis.degraded } : {}),
         };
-        cache.write(r.fp, entry);
         entries.push(entry);
+        generated.push({ fp: r.fp, entry });
         const nn = entry.columns.filter((c) => !effectiveNullable(c)).length;
         const tag = entry.degraded ? ` [degraded: ${entry.degraded.reason}]` : "";
         log(`  ✓ ${formatSite(r.sites[0])} → ${r.paramOids.length} param(s), ${r.fields.length} col(s) [${nn} non-null]${tag}`);
     }
-    let pruned = 0;
-    if (opts.prune !== false) {
-        pruned = cache.prune(unique.keys()).length;
+    if (failures > 0) {
+        return { sites: sites.length, entries: entries.length, failures, pruned: 0, functions: 0, diagnostics };
+    }
+    let functions;
+    try {
+        functions = await introspectFunctions(client, schema);
+    }
+    catch (error) {
+        throw fatal("introspect", error);
+    }
+    let pruned;
+    try {
+        pruned = cache.replaceAll(generated, opts.prune !== false).length;
         if (pruned > 0)
             log(`pruned ${pruned} orphaned cache entry/entries`);
+        writeFunctionCache(opts.cacheDir, functions);
+        writeCacheManifest(opts.cacheDir, prepareConfigHash(userCfg));
+        emitDts(opts.dtsPath, entries, functions);
     }
-    emitDts(opts.dtsPath, entries);
-    return { entries: entries.length, failures, pruned };
+    catch (error) {
+        throw fatal("cache", error);
+    }
+    return { sites: sites.length, entries: entries.length, failures, pruned, functions: functions.length, diagnostics };
 }
 export async function runPrepare(opts) {
+    if (opts.verify) {
+        const verification = await verifyPrepareArtifacts(opts, opts.json ? () => { } : console.log, opts.json ? () => { } : console.error);
+        if (opts.json) {
+            console.log(JSON.stringify({
+                formatVersion: 1,
+                ok: verification.ok,
+                mode: "verify",
+                ...verification.result,
+                changed: verification.changed,
+            }, null, 2));
+        }
+        if (!verification.ok)
+            process.exitCode = 1;
+        return;
+    }
     if (opts.check) {
-        const sites = scanProject(opts.root);
-        console.log(`scanned: found ${sites.length} sql() call site(s)`);
+        let userCfg;
+        try {
+            userCfg = await loadConfig(opts.root);
+        }
+        catch (error) {
+            throw fatal("config", error);
+        }
+        let sites;
+        try {
+            sites = scanProject(opts.root, userCfg.scan);
+        }
+        catch (error) {
+            throw fatal("scan", error);
+        }
+        if (!opts.json)
+            console.log(`scanned: found ${sites.length} sql() call site(s)`);
         const cache = new Cache(opts.cacheDir);
+        try {
+            assertCacheManifest(opts.cacheDir, prepareConfigHash(userCfg));
+        }
+        catch (error) {
+            throw fatal("cache", error);
+        }
         const unique = new Map();
         for (const s of sites) {
             const fp = fingerprint(s.query);
@@ -361,37 +549,135 @@ export async function runPrepare(opts) {
             else
                 unique.set(fp, { fp, query: s.query, sites: [s] });
         }
-        let stale = 0;
+        const diagnostics = [];
         for (const { fp, query, sites: ss } of unique.values()) {
             if (!cache.has(fp)) {
-                stale++;
-                console.error(`stale: ${formatSite(ss[0])} — query not in cache`);
-                console.error(`       query: ${snippet(query)}`);
+                const site = ss[0];
+                diagnostics.push({
+                    severity: "error",
+                    phase: "cache",
+                    message: "query is not in the offline cache",
+                    file: site.file,
+                    line: site.line,
+                    column: site.column,
+                    query,
+                });
+                if (!opts.json) {
+                    console.error(`stale: ${formatSite(site)} — query not in cache`);
+                    console.error(`       query: ${snippet(query)}`);
+                }
+            }
+        }
+        if (diagnostics.length > 0) {
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    formatVersion: 1,
+                    ok: false,
+                    mode: "check",
+                    sites: sites.length,
+                    entries: unique.size - diagnostics.length,
+                    failures: diagnostics.length,
+                    pruned: 0,
+                    functions: 0,
+                    diagnostics,
+                }, null, 2));
+            }
+            else {
+                console.error(`\nsqlx-js prepare --check: ${diagnostics.length} stale/missing entries. Run \`sqlx-js prepare\` against a live DB.`);
             }
+            process.exitCode = 1;
+            return;
         }
-        if (stale > 0) {
-            console.error(`\nsqlx-js prepare --check: ${stale} stale/missing entries. Run \`sqlx-js prepare\` against a live DB.`);
-            process.exit(1);
+        let entries;
+        let functions;
+        try {
+            entries = [...unique.values()].map((u) => {
+                const entry = cache.read(u.fp);
+                return entry ? { ...entry, ...siteUsage(u.sites) } : null;
+            }).filter((e) => e !== null);
+            functions = readFunctionCache(opts.cacheDir);
+            emitDts(opts.dtsPath, entries, functions);
+        }
+        catch (error) {
+            throw fatal("cache", error);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({
+                formatVersion: 1,
+                ok: true,
+                mode: "check",
+                sites: sites.length,
+                entries: entries.length,
+                failures: 0,
+                pruned: 0,
+                functions: functions.length,
+                diagnostics: [],
+            }, null, 2));
+        }
+        else {
+            console.log(`ok — ${entries.length} unique queries, ${functions.length} function(s), types regenerated`);
         }
-        const entries = [...unique.values()].map((u) => {
-            const entry = cache.read(u.fp);
-            return entry ? { ...entry, ...siteUsage(u.sites) } : null;
-        }).filter((e) => e !== null);
-        emitDts(opts.dtsPath, entries);
-        console.log(`ok — ${entries.length} unique queries, types regenerated`);
         return;
     }
     const session = await openSession(opts);
     try {
-        const r = await prepareOnce(opts, session);
+        const r = await prepareOnce(opts, session, opts.json ? () => { } : console.log, opts.json ? () => { } : console.error);
+        if (opts.json) {
+            console.log(JSON.stringify({ formatVersion: 1, ok: r.failures === 0, mode: "prepare", ...r }, null, 2));
+        }
         if (r.failures > 0) {
-            console.error(`\n${r.failures} query/queries failed to prepare`);
-            await session.client.end();
-            process.exit(1);
+            if (!opts.json)
+                console.error(`\n${r.failures} query/queries failed to prepare`);
+            process.exitCode = 1;
+            return;
         }
-        console.log(`\nprepared ${r.entries} unique query/queries → ${opts.dtsPath}`);
+        if (!opts.json)
+            console.log(`\nprepared ${r.entries} unique query/queries, ${r.functions} function(s) → ${opts.dtsPath}`);
     }
     finally {
         await session.client.end();
     }
 }
+export async function verifyPrepareArtifacts(opts, log = console.log, err = console.error) {
+    const tmp = mkdtempSync(join(tmpdir(), "sqlx-js-verify-"));
+    const cacheDir = join(tmp, "cache");
+    const dtsPath = join(tmp, "sqlx-js-env.d.ts");
+    const verifyOpts = {
+        ...opts,
+        cacheDir,
+        dtsPath,
+        check: false,
+        verify: false,
+        prune: true,
+    };
+    let session;
+    try {
+        session = await openSession(verifyOpts);
+        const result = await prepareOnce(verifyOpts, session, log, err);
+        if (result.failures > 0) {
+            err(`\n${result.failures} query/queries failed to prepare`);
+            return { ok: false, result, changed: [] };
+        }
+        let comparison;
+        try {
+            comparison = compareArtifacts({ cacheDir: opts.cacheDir, dtsPath: opts.dtsPath }, { cacheDir, dtsPath });
+        }
+        catch (error) {
+            throw fatal("verify", error);
+        }
+        if (!comparison.ok) {
+            err("sqlx-js prepare --verify: generated artifacts are stale:");
+            for (const file of comparison.changed)
+                err(`  ${file}`);
+            err("Run `sqlx-js prepare` and commit the regenerated artifacts.");
+            return { ok: false, result, changed: comparison.changed };
+        }
+        log(`verified ${result.entries} query/queries and ${result.functions} function(s); generated artifacts are current`);
+        return { ok: true, result, changed: [] };
+    }
+    finally {
+        if (session)
+            await session.client.end();
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}

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

@@ -1,4 +1,5 @@
 import { openSession, prepareOnce, type PrepareOptions, type PrepareSession } from "./prepare.js";
+export declare function shouldWatchFile(filename: string): boolean;
 export type WatchPrepareHookResult = {
     resetSession?: boolean;
 };

package/dist/src/commands/watch.js

@@ -1,9 +1,28 @@
 import { watch as fsWatch } from "node:fs";
 import { basename } from "node:path";
 import { openSession, prepareOnce } from "./prepare.js";
+import { configHash, loadConfig } from "../config.js";
 const EXT_RE = /\.(ts|tsx|mts|cts|sql)$/;
 const SKIP_DIRS = ["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"];
 const DEBOUNCE_MS = 150;
+const CONFIG_FILES = new Set([
+    "sqlx-js.config.ts",
+    "sqlx-js.config.mts",
+    "sqlx-js.config.js",
+    "sqlx-js.config.mjs",
+]);
+export function shouldWatchFile(filename) {
+    const file = filename.replace(/\\/g, "/");
+    if (SKIP_DIRS.some((dir) => file === dir || file.startsWith(`${dir}/`) || file.includes(`/${dir}/`))) {
+        return false;
+    }
+    const base = basename(file);
+    if (base === "sqlx-js-env.d.ts" || base === "sqlx-js.d.ts")
+        return false;
+    if (CONFIG_FILES.has(base) || /^tsconfig(?:\.[^.]+)*\.json$/.test(base))
+        return true;
+    return EXT_RE.test(file);
+}
 const DEFAULT_DEPS = { openSession, prepareOnce };
 async function closeSession(session) {
     if (!session)
@@ -15,7 +34,9 @@ async function closeSession(session) {
 }
 export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_DEPS) {
     const hookResult = await opts.beforePrepare?.();
-    if (hookResult?.resetSession === true) {
+    const currentConfig = await loadConfig(opts.root);
+    if (hookResult?.resetSession === true ||
+        (state.session !== null && configHash(state.session.userCfg) !== configHash(currentConfig))) {
         await closeSession(state.session);
         state.session = null;
     }
@@ -70,14 +91,7 @@ export async function runWatch(opts) {
     const watcher = fsWatch(opts.root, { recursive: true }, (_event, filename) => {
         if (!filename)
             return;
-        const raw = filename.toString();
-        const f = raw.replace(/\\/g, "/");
-        if (SKIP_DIRS.some((d) => f === d || f.startsWith(`${d}/`) || f.includes(`/${d}/`)))
-            return;
-        const base = basename(f);
-        if (base === "sqlx-js-env.d.ts" || base === "sqlx-js.d.ts")
-            return;
-        if (!EXT_RE.test(f))
+        if (!shouldWatchFile(filename.toString()))
             return;
         trigger();
     });

package/dist/src/config.d.ts

@@ -1,6 +1,33 @@
+export type ScanConfig = {
+    include?: string[];
+    exclude?: string[];
+};
 export type SqlxJsConfig = {
     jsonbTypes?: Record<string, string>;
     customTypes?: Record<string, string>;
+    scan?: ScanConfig;
+    schema?: {
+        provider?: "builtin" | "pgschema";
+        file?: string;
+        schemas?: string[];
+        command?: string;
+    };
 };
+export declare function defineConfig<T extends SqlxJsConfig>(config: T): T;
+export declare function loadRootEnv(root: string): string | undefined;
+export declare function configPath(root: string): string | undefined;
 export declare function loadConfig(root: string): Promise<SqlxJsConfig>;
+export declare function prepareConfigHash(cfg: SqlxJsConfig): string;
+export declare function configHash(cfg: SqlxJsConfig): string;
+export declare function loadConfigInfo(root: string): Promise<{
+    config: SqlxJsConfig;
+    path?: string;
+}>;
+export declare function assertSupportedRuntime(): void;
+export declare function runtimeVersion(): {
+    runtime: "node" | "bun";
+    version: string;
+};
+export declare function nativeTypeScriptEnabled(): boolean | string;
+export declare function envFilePath(root: string): string;
 export declare function lookupJsonbType(cfg: SqlxJsConfig, schema: string, table: string, column: string): string | undefined;