@onreza/sqlx-js 0.4.0 → 0.6.0

package/dist/src/commands/prepare.js

@@ -1,18 +1,29 @@
+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";
+import { containsUnknownType } from "../type-inspection.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";
@@ -56,15 +67,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));
 }
@@ -114,6 +149,37 @@ function isAliasOrExpression(f, schema) {
     const real = schema.columnNameByAttno(f.tableOid, f.columnAttr);
     return real !== undefined && real !== f.name;
 }
+function duplicateOutputColumns(fields) {
+    const counts = new Map();
+    for (const field of fields) {
+        const name = parseColumnOverride(field.name).name;
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    return [...counts].filter(([, count]) => count > 1).map(([name]) => name).sort();
+}
+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}`;
 }
@@ -130,11 +196,55 @@ function siteUsage(sites) {
         ...(filePaths.length > 0 ? { filePaths } : {}),
     };
 }
+function inferenceIssues(entry) {
+    const issues = [];
+    if (entry.degraded)
+        issues.push(`nullability inference degraded: ${entry.degraded.reason}`);
+    entry.paramTsTypes.forEach((type, index) => {
+        if (containsUnknownType(type))
+            issues.push(`parameter $${index + 1} resolved to ${type}`);
+    });
+    for (const column of entry.columns) {
+        if (containsUnknownType(column.tsType)) {
+            issues.push(`result column ${JSON.stringify(column.name)} resolved to ${column.tsType}`);
+        }
+    }
+    return issues;
+}
+function inferenceDiagnostics(entry, site, strict) {
+    return inferenceIssues(entry).map((message) => ({
+        severity: strict ? "error" : "warning",
+        phase: "inference",
+        message,
+        file: site.file,
+        line: site.line,
+        column: site.column,
+        query: entry.query,
+    }));
+}
 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 };
@@ -192,8 +302,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) {
@@ -213,12 +330,41 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         const site = ss[0];
         const outcome = describeResults.get(fp);
         if (outcome.ok) {
+            const duplicates = duplicateOutputColumns(outcome.fields);
+            if (duplicates.length > 0) {
+                failures++;
+                const message = `duplicate output column name(s): ${duplicates.join(", ")}. Alias each result column to a unique name`;
+                diagnostics.push({
+                    severity: "error",
+                    phase: "result-shape",
+                    message,
+                    file: site.file,
+                    line: site.line,
+                    column: site.column,
+                    query,
+                });
+                err(`  ✗ ${formatSite(site)} — ${message}`);
+                err(`      query: ${snippet(query)}`);
+                continue;
+            }
             raw.push({ fp, query, sites: ss, paramOids: outcome.paramOids, fields: outcome.fields });
             continue;
         }
         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}`);
@@ -231,6 +377,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)}`);
         }
@@ -245,8 +400,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();
@@ -258,6 +418,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;
@@ -268,31 +437,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) {
@@ -303,8 +485,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;
@@ -317,7 +505,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) => {
@@ -325,7 +513,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 } : {}),
@@ -334,31 +522,88 @@ 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);
+        const entryDiagnostics = inferenceDiagnostics(entry, r.sites[0], opts.strictInference === true);
+        diagnostics.push(...entryDiagnostics);
+        if (entryDiagnostics.length > 0) {
+            for (const diagnostic of entryDiagnostics) {
+                const label = diagnostic.severity === "error" ? "inference failed" : "inference warning";
+                err(`  ${label}: ${formatSite(r.sites[0])} — ${diagnostic.message}`);
+            }
+            if (opts.strictInference) {
+                failures++;
+                continue;
+            }
+        }
         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 (pruned > 0)
-            log(`pruned ${pruned} orphaned cache entry/entries`);
+    if (failures > 0) {
+        return { sites: sites.length, entries: entries.length, failures, pruned: 0, functions: 0, diagnostics };
     }
-    let functions = [];
-    if (failures === 0) {
+    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);
+    }
+    catch (error) {
+        throw fatal("cache", error);
     }
-    emitDts(opts.dtsPath, entries, functions);
-    return { entries: entries.length, failures, pruned, functions: functions.length };
+    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);
@@ -368,38 +613,170 @@ 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 (stale > 0) {
-            console.error(`\nsqlx-js prepare --check: ${stale} stale/missing entries. Run \`sqlx-js prepare\` against a live DB.`);
-            process.exit(1);
+        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;
+        }
+        const entries = [];
+        let inferenceFailures = 0;
+        let functions;
+        try {
+            for (const u of unique.values()) {
+                const entry = cache.read(u.fp);
+                if (!entry)
+                    continue;
+                const current = { ...entry, ...siteUsage(u.sites) };
+                const entryDiagnostics = inferenceDiagnostics(current, u.sites[0], opts.strictInference === true);
+                diagnostics.push(...entryDiagnostics);
+                if (opts.strictInference && entryDiagnostics.length > 0) {
+                    inferenceFailures++;
+                    continue;
+                }
+                entries.push(current);
+            }
+            functions = readFunctionCache(opts.cacheDir);
+            if (inferenceFailures > 0) {
+                if (opts.json) {
+                    console.log(JSON.stringify({
+                        formatVersion: 1,
+                        ok: false,
+                        mode: "check",
+                        sites: sites.length,
+                        entries: entries.length,
+                        failures: inferenceFailures,
+                        pruned: 0,
+                        functions: functions.length,
+                        diagnostics,
+                    }, null, 2));
+                }
+                else {
+                    for (const diagnostic of diagnostics) {
+                        console.error(`inference failed: ${diagnostic.file}:${diagnostic.line}:${diagnostic.column} — ${diagnostic.message}`);
+                    }
+                }
+                process.exitCode = 1;
+                return;
+            }
+            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 {
+            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 entries = [...unique.values()].map((u) => {
-            const entry = cache.read(u.fp);
-            return entry ? { ...entry, ...siteUsage(u.sites) } : null;
-        }).filter((e) => e !== null);
-        const functions = readFunctionCache(opts.cacheDir);
-        emitDts(opts.dtsPath, entries, functions);
-        console.log(`ok — ${entries.length} unique queries, ${functions.length} function(s), 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, ${r.functions} function(s) → ${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/schema.js

@@ -1,6 +1,6 @@
 import { introspectDatabase, readSchemaSnapshot, schemaSnapshotEqual, schemaSnapshotExists, writeSchemaManifest, writeSchemaSnapshot } from "../schema-snapshot.js";
 import { PgClient, parseDatabaseUrl } from "../pg/wire.js";
-import { acquireMigrateLock, applyPending, DEFAULT_MIGRATE_LOCK_KEY, releaseMigrateLock } from "./migrate.js";
+import { acquireMigrateLock, applyPending, DEFAULT_MIGRATE_LOCK_KEY, releaseMigrateLock } from "../migration-core.js";
 export async function applyShadowMigrations(databaseUrl, migrationsDir, log = console.log) {
     const client = new PgClient(parseDatabaseUrl(databaseUrl));
     await client.connect();

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;
 };