@onreza/sqlx-js 0.7.0 → 0.9.0

package/dist/src/cache.js

@@ -1,143 +1,23 @@
-import { createHash, randomBytes } from "node:crypto";
+import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { isBuiltinOid } from "./pg/oids.js";
-export const CACHE_FORMAT_VERSION = 2;
-export const GENERATOR_REVISION = 4;
+import { queryId } from "./query-id.js";
+import { rewriteNamedParameters } from "./sql-params.js";
+export const CACHE_FORMAT_VERSION = 3;
+export const GENERATOR_REVISION = 6;
 export const CACHE_MANIFEST_FILE = "cache-manifest.json";
+export class CacheManifestStaleError extends Error {
+    constructor(path) {
+        super(`sqlx-js: cache manifest is stale: ${path}. Run \`sqlx-js prepare\`.`);
+        this.name = "CacheManifestStaleError";
+    }
+}
 export function portableCacheOid(oid) {
     return isBuiltinOid(oid) ? oid : 0;
 }
 export function fingerprint(query) {
-    const norm = normalizeForFingerprint(query);
-    return createHash("sha256").update(norm).digest("hex").slice(0, 16);
-}
-function normalizeForFingerprint(query) {
-    let out = "";
-    let pendingSpace = false;
-    let i = 0;
-    const emit = (text) => {
-        if (pendingSpace && out.length > 0)
-            out += " ";
-        out += text;
-        pendingSpace = false;
-    };
-    const markSpace = () => {
-        if (out.length > 0)
-            pendingSpace = true;
-    };
-    while (i < query.length) {
-        const ch = query[i];
-        if (/\s/.test(ch)) {
-            markSpace();
-            i++;
-            continue;
-        }
-        if (ch === "-" && query[i + 1] === "-") {
-            i = readLineComment(query, i);
-            markSpace();
-            continue;
-        }
-        if (ch === "/" && query[i + 1] === "*") {
-            i = readBlockComment(query, i);
-            markSpace();
-            continue;
-        }
-        if (ch === "'") {
-            const next = readSingleQuoted(query, i, isEscapeStringPrefix(query, i));
-            emit(query.slice(i, next));
-            i = next;
-            continue;
-        }
-        if (ch === "\"") {
-            const next = readQuotedIdentifier(query, i);
-            emit(query.slice(i, next));
-            i = next;
-            continue;
-        }
-        if (ch === "$") {
-            const next = readDollarQuoted(query, i);
-            if (next !== null) {
-                emit(query.slice(i, next));
-                i = next;
-                continue;
-            }
-        }
-        emit(ch);
-        i++;
-    }
-    return out;
-}
-function readSingleQuoted(query, start, escapeBackslash) {
-    let i = start + 1;
-    while (i < query.length) {
-        const ch = query[i];
-        if (escapeBackslash && ch === "\\") {
-            i += 2;
-            continue;
-        }
-        if (ch === "'") {
-            if (query[i + 1] === "'") {
-                i += 2;
-                continue;
-            }
-            return i + 1;
-        }
-        i++;
-    }
-    return query.length;
-}
-function readQuotedIdentifier(query, start) {
-    let i = start + 1;
-    while (i < query.length) {
-        if (query[i] === "\"") {
-            if (query[i + 1] === "\"") {
-                i += 2;
-                continue;
-            }
-            return i + 1;
-        }
-        i++;
-    }
-    return query.length;
-}
-function readDollarQuoted(query, start) {
-    let tagEnd = start + 1;
-    while (tagEnd < query.length && /[A-Za-z0-9_]/.test(query[tagEnd]))
-        tagEnd++;
-    if (query[tagEnd] !== "$")
-        return null;
-    const tag = query.slice(start, tagEnd + 1);
-    const end = query.indexOf(tag, tagEnd + 1);
-    return end === -1 ? query.length : end + tag.length;
-}
-function readLineComment(query, start) {
-    const end = query.indexOf("\n", start + 2);
-    return end === -1 ? query.length : end + 1;
-}
-function readBlockComment(query, start) {
-    let depth = 1;
-    let i = start + 2;
-    while (i < query.length && depth > 0) {
-        if (query[i] === "/" && query[i + 1] === "*") {
-            depth++;
-            i += 2;
-            continue;
-        }
-        if (query[i] === "*" && query[i + 1] === "/") {
-            depth--;
-            i += 2;
-            continue;
-        }
-        i++;
-    }
-    return i;
-}
-function isEscapeStringPrefix(query, quoteIndex) {
-    if (quoteIndex === 0 || query[quoteIndex - 1]?.toLowerCase() !== "e")
-        return false;
-    const beforePrefix = query[quoteIndex - 2];
-    return beforePrefix === undefined || !/[A-Za-z0-9_$]/.test(beforePrefix);
+    return queryId(query);
 }
 export function effectiveNullable(c) {
     if (c.override === "non-null")
@@ -166,6 +46,27 @@ function assertEntryShape(fp, raw) {
         throw new Error(`sqlx-js: cache entry ${fp}.json is malformed`);
     }
     const cols = raw.columns;
+    const entry = raw;
+    let expectedNames;
+    try {
+        if (typeof entry.query !== "string")
+            throw new Error("query must be a string");
+        expectedNames = rewriteNamedParameters(entry.query).names;
+    }
+    catch {
+        throw new Error(`sqlx-js: cache entry ${fp}.json has malformed named parameter metadata. Run \`sqlx-js prepare\`.`);
+    }
+    if (entry.paramNames !== undefined || expectedNames.length > 0) {
+        if (!Array.isArray(entry.paramNames) ||
+            !entry.paramNames.every((name) => typeof name === "string") ||
+            !Array.isArray(entry.paramTsTypes) ||
+            entry.paramNames.length !== entry.paramTsTypes.length ||
+            new Set(entry.paramNames).size !== entry.paramNames.length ||
+            entry.paramNames.length !== expectedNames.length ||
+            entry.paramNames.some((name, index) => name !== expectedNames[index])) {
+            throw new Error(`sqlx-js: cache entry ${fp}.json has malformed named parameter metadata. Run \`sqlx-js prepare\`.`);
+        }
+    }
     if (cols.length > 0) {
         const c = cols[0];
         if ("forceNonNull" in c || "forceNullable" in c) {
@@ -297,7 +198,7 @@ export function readCacheManifest(cacheDir) {
     if (value.cacheFormat !== CACHE_FORMAT_VERSION ||
         value.generatorRevision !== GENERATOR_REVISION ||
         typeof value.configHash !== "string") {
-        throw new Error(`sqlx-js: cache manifest is stale: ${path}. Run \`sqlx-js prepare\`.`);
+        throw new CacheManifestStaleError(path);
     }
     return value;
 }
@@ -307,7 +208,7 @@ export function assertCacheManifest(cacheDir, configHash) {
         throw new Error(`sqlx-js: cache manifest is missing. Run \`sqlx-js prepare\` to regenerate the cache.`);
     }
     if (manifest.configHash !== configHash) {
-        throw new Error("sqlx-js: cache was generated with a different jsonbTypes/customTypes config. Run `sqlx-js prepare`.");
+        throw new Error("sqlx-js: cache was generated with a different jsonbTypes/customTypes config or other type/function catalog settings. Run `sqlx-js prepare`.");
     }
     return manifest;
 }

package/dist/src/codegen.js

@@ -7,7 +7,9 @@ function entrySignature(e) {
         const nullable = e.paramNullable?.[i] === true;
         return nullable ? `${t} | null` : t;
     });
-    const params = paramTypes.length === 0 ? "[]" : `[${paramTypes.join(", ")}]`;
+    const params = e.paramNames && e.paramNames.length > 0
+        ? `{ ${e.paramNames.map((name, index) => `${JSON.stringify(name)}: ${paramTypes[index]}`).join("; ")} }`
+        : paramTypes.length === 0 ? "[]" : `[${paramTypes.join(", ")}]`;
     if (!e.hasResultSet)
         return { params, row: "never" };
     const cols = e.columns.map((c) => {

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

@@ -0,0 +1,28 @@
+import type { SqlxJsConfig } from "../config.js";
+export type CiStep = {
+    name: string;
+    args: string[];
+    check?: "pgschema-plan";
+};
+export type CiStepResult = {
+    name: string;
+    ok: boolean;
+    durationMs: number;
+    exitCode: number;
+    stderr?: string;
+};
+export type CiOptions = {
+    executable: string;
+    cliPath: string;
+    root: string;
+    config: SqlxJsConfig;
+    schemaPath: string;
+    json?: boolean;
+    shadowUrl?: string;
+    shadowAdminUrl?: string;
+    migrationsDir?: string;
+    dtsPath?: string;
+};
+export declare function buildCiSteps(opts: Pick<CiOptions, "config" | "root" | "schemaPath" | "shadowUrl" | "shadowAdminUrl" | "migrationsDir" | "dtsPath">): CiStep[];
+export declare function assertPgschemaPlanClean(path: string): void;
+export declare function runCi(opts: CiOptions): void;

package/dist/src/commands/ci.js

@@ -0,0 +1,103 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const PLAN_PATH = "{sqlx-js-ci-plan}";
+export function buildCiSteps(opts) {
+    const root = ["--root", opts.root];
+    const shadow = opts.shadowUrl ? ["--shadow-url", opts.shadowUrl] : [];
+    const shadowAdmin = opts.shadowAdminUrl ? ["--shadow-admin-url", opts.shadowAdminUrl] : [];
+    const migrations = opts.migrationsDir ? ["--migrations", opts.migrationsDir] : [];
+    const dts = opts.dtsPath ? ["--dts", opts.dtsPath] : [];
+    const steps = opts.config.schema?.provider === "pgschema"
+        ? [
+            { name: "pgschema", args: ["db", "check", ...root] },
+            {
+                name: "pgschema-plan",
+                args: ["db", "plan", ...root, "--", "--output-json", PLAN_PATH, "--no-color"],
+                check: "pgschema-plan",
+            },
+            { name: "prepare-live", args: ["prepare", "--verify", "--strict-inference", ...shadow, ...dts, ...root] },
+        ]
+        : [{
+                name: "migrations",
+                args: ["migrate", "verify", "--strict-inference", ...shadow, ...shadowAdmin, ...migrations, ...dts, ...root],
+            }];
+    steps.push({ name: "prepare-offline", args: ["prepare", "--check", "--strict-inference", ...dts, ...root] });
+    if (existsSync(opts.schemaPath)) {
+        steps.push({ name: "schema", args: ["schema", "check", ...shadow, "--schema", opts.schemaPath, ...migrations, ...root] });
+    }
+    return steps;
+}
+export function assertPgschemaPlanClean(path) {
+    const plan = JSON.parse(readFileSync(path, "utf8"));
+    if (plan.groups === null)
+        return;
+    if (!Array.isArray(plan.groups))
+        throw new Error("plan JSON does not contain groups as an array or null");
+    if (plan.groups.length > 0)
+        throw new Error(`pgschema plan contains ${plan.groups.length} unapplied change group(s)`);
+}
+export function runCi(opts) {
+    const results = [];
+    const temp = mkdtempSync(join(tmpdir(), "sqlx-js-ci-"));
+    try {
+        for (const step of buildCiSteps(opts)) {
+            if (!opts.json)
+                console.log(`ci: ${step.name}`);
+            const started = performance.now();
+            const planPath = join(temp, "pgschema-plan.json");
+            const args = step.args.map((arg) => arg === PLAN_PATH ? planPath : arg);
+            const result = spawnSync(opts.executable, [opts.cliPath, ...args], {
+                encoding: "utf8",
+                env: process.env,
+                stdio: opts.json ? ["ignore", "ignore", "pipe"] : "inherit",
+                maxBuffer: 4 * 1024 * 1024,
+            });
+            let exitCode = result.status ?? 1;
+            let checkError;
+            if (exitCode === 0 && step.check === "pgschema-plan") {
+                try {
+                    assertPgschemaPlanClean(planPath);
+                }
+                catch (error) {
+                    checkError = error.message.startsWith("pgschema plan contains")
+                        ? error.message
+                        : `cannot verify pgschema plan: ${error.message}`;
+                    exitCode = 1;
+                }
+            }
+            if (result.error) {
+                checkError = result.error.message;
+                exitCode = 1;
+            }
+            else if (result.signal) {
+                checkError = `terminated by signal ${result.signal}`;
+                exitCode = 1;
+            }
+            if (checkError && !opts.json)
+                console.error(`ci: ${step.name}: ${checkError}`);
+            results.push({
+                name: step.name,
+                ok: exitCode === 0,
+                durationMs: Math.round(performance.now() - started),
+                exitCode,
+                ...(opts.json && exitCode !== 0 && (checkError || result.stderr)
+                    ? { stderr: [result.stderr?.trim(), checkError].filter(Boolean).join("\n") }
+                    : {}),
+            });
+            if (exitCode !== 0)
+                break;
+        }
+    }
+    finally {
+        rmSync(temp, { recursive: true, force: true });
+    }
+    const ok = results.length > 0 && results.every((result) => result.ok);
+    if (opts.json)
+        console.log(JSON.stringify({ formatVersion: 1, ok, results }, null, 2));
+    else if (ok)
+        console.log(`ci: ok — ${results.length} check(s) passed`);
+    if (!ok)
+        process.exitCode = 1;
+}

package/dist/src/commands/init.js

@@ -6,9 +6,14 @@ export default defineConfig({
   // Map jsonb columns/params to TypeScript types declared in a .d.ts, e.g.
   //   "users.settings": "SqlxJsJson.UserSettings",
   jsonbTypes: {},
+  // Assert narrower TypeScript types for direct scalar columns.
+  columnTypes: {},
   // Map PostgreSQL type names to TypeScript types, e.g.
   //   geometry: "GeoJSON.Geometry",
   customTypes: {},
+  // Extension-owned functions are excluded by default. Set false to disable
+  // the generated function catalog entirely.
+  functionCatalog: {},
 });
 `;
 const PGSCHEMA_CONFIG_TEMPLATE = `import { defineConfig } from "@onreza/sqlx-js";
@@ -20,7 +25,9 @@ export default defineConfig({
     schemas: ["public"],
   },
   jsonbTypes: {},
+  columnTypes: {},
   customTypes: {},
+  functionCatalog: {},
 });
 `;
 const ENV_TEMPLATE = `# Connection string used by sqlx-js prepare/migrate and the runtime.
@@ -143,6 +150,8 @@ export function runInit(opts) {
             "sqlx:check": "sqlx-js prepare --check",
             "sqlx:offline": "sqlx-js prepare --offline",
             "sqlx:verify": "sqlx-js prepare --verify --strict-inference",
+            "sqlx:ci": "sqlx-js ci",
+            "sqlx:queries": "sqlx-js queries --json",
         };
         let changed = false;
         for (const [name, command] of Object.entries(defaults)) {

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

@@ -34,6 +34,8 @@ export type PrepareDiagnostic = {
     line?: number;
     column?: number;
     query?: string;
+    queryId?: string;
+    queryName?: string;
     code?: string;
     position?: number;
     hint?: string;

package/dist/src/commands/prepare.js

@@ -8,16 +8,17 @@ 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, prepareConfigHash } from "../config.js";
+import { loadConfig, lookupColumnType, lookupJsonbType, prepareConfigHash } from "../config.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";
 import { compareArtifacts } from "../artifacts.js";
 import { containsUnknownType } from "../type-inspection.js";
+import { originalPosition, rewriteNamedParameters } from "../sql-params.js";
 const JSON_OIDS = new Set([114, 3802]);
 const JSON_ARRAY_OIDS = new Set([199, 3807]);
-const JSON_INPUT_VALUE = 'import("@onreza/sqlx-js").JsonInputValue';
+const JSON_INPUT_VALUE = "unknown";
 function jsonParameter(type) {
     return `import("@onreza/sqlx-js").JsonParameter<${type}>`;
 }
@@ -47,6 +48,12 @@ function resolveTs(oid, customLookup) {
     }
     return oidToTs(oid).ts;
 }
+function isScalarColumnType(oid, schema) {
+    if (JSON_OIDS.has(oid) || JSON_ARRAY_OIDS.has(oid) || arrayElementOid(oid) !== undefined)
+        return false;
+    const custom = schema.customType(oid);
+    return custom?.kind !== "enumArray" && custom?.kind !== "scalarArray" && custom?.kind !== "compositeArray";
+}
 function resolveColumnTs(f, schema, cfg) {
     if (f.tableOid !== 0 && f.columnAttr !== 0) {
         const tbl = schema.tableNameByOid(f.tableOid);
@@ -62,13 +69,25 @@ function resolveColumnTs(f, schema, cfg) {
                 if (decl)
                     return `(${decl})[]`;
             }
+            if (isScalarColumnType(f.typeOid, schema)) {
+                const decl = lookupColumnType(cfg, tbl.schema, tbl.name, colName);
+                if (decl)
+                    return decl;
+            }
         }
     }
     return resolveTs(f.typeOid, (oid) => schema.customType(oid));
 }
 function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
+    const target = paramMap.get(paramIndex);
+    if (isScalarColumnType(paramOid, schema) && target) {
+        const column = resolveTargetColumn(target, schema);
+        const table = resolvedTargetTable(target, schema);
+        const decl = column && table ? lookupColumnType(cfg, table.schema, table.name, column) : undefined;
+        if (decl)
+            return decl;
+    }
     if (JSON_OIDS.has(paramOid)) {
-        const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
             const table = resolvedTargetTable(target, schema);
@@ -79,7 +98,6 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
         return jsonParameter(JSON_INPUT_VALUE);
     }
     if (JSON_ARRAY_OIDS.has(paramOid)) {
-        const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
             const table = resolvedTargetTable(target, schema);
@@ -187,7 +205,17 @@ function fatal(phase, error) {
     return new PrepareFatalError(phase, message, location, { cause: error });
 }
 function formatSite(s) {
-    return `${s.file}:${s.line}:${s.column}`;
+    return `${s.file}:${s.line}:${s.column}${s.queryName ? ` [${s.queryName}]` : ""}`;
+}
+function siteDiagnostic(site) {
+    return {
+        file: site.file,
+        line: site.line,
+        column: site.column,
+        query: site.query,
+        queryId: fingerprint(site.query),
+        ...(site.queryName ? { queryName: site.queryName } : {}),
+    };
 }
 function snippet(query, max = 80) {
     const oneLine = query.replace(/\s+/g, " ").trim();
@@ -207,8 +235,9 @@ function inferenceIssues(entry) {
     if (entry.degraded)
         issues.push(`nullability inference degraded: ${entry.degraded.reason}`);
     entry.paramTsTypes.forEach((type, index) => {
+        const parameter = entry.paramNames?.[index] ? `$${entry.paramNames[index]}` : `$${index + 1}`;
         if (containsUnknownType(type))
-            issues.push(`parameter $${index + 1} resolved to ${type}`);
+            issues.push(`parameter ${parameter} resolved to ${type}`);
     });
     for (const column of entry.columns) {
         if (containsUnknownType(column.tsType)) {
@@ -222,10 +251,7 @@ function inferenceDiagnostics(entry, site, strict) {
         severity: strict ? "error" : "warning",
         phase: "inference",
         message,
-        file: site.file,
-        line: site.line,
-        column: site.column,
-        query: entry.query,
+        ...siteDiagnostic(site),
     }));
 }
 export async function openSession(opts) {
@@ -326,12 +352,13 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
     let failures = 0;
     const unique = new Map();
     for (const s of sites) {
+        const rewritten = rewriteNamedParameters(s.query);
         const fp = fingerprint(s.query);
         const existing = unique.get(fp);
         if (existing)
             existing.sites.push(s);
         else
-            unique.set(fp, { fp, query: s.query, sites: [s] });
+            unique.set(fp, { fp, query: rewritten.query, paramNames: rewritten.names, sites: [s] });
     }
     const raw = [];
     const reusedEntries = [];
@@ -369,56 +396,48 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                     severity: "error",
                     phase: "result-shape",
                     message,
-                    file: site.file,
-                    line: site.line,
-                    column: site.column,
-                    query,
+                    ...siteDiagnostic(site),
                 });
                 err(`  ✗ ${formatSite(site)} — ${message}`);
-                err(`      query: ${snippet(query)}`);
+                err(`      query: ${snippet(site.query)}`);
                 continue;
             }
-            raw.push({ fp, query, sites: ss, paramOids: outcome.paramOids, fields: outcome.fields });
+            raw.push({ fp, query, sites: ss, paramOids: outcome.paramOids, fields: outcome.fields, paramNames: toPrepare.get(fp).paramNames });
             continue;
         }
         failures++;
         const e = outcome.error;
         if (e instanceof PgError) {
+            const position = e.position ? originalPosition(rewriteNamedParameters(site.query), e.position) : undefined;
             diagnostics.push({
                 severity: "error",
                 phase: "describe",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query,
+                ...siteDiagnostic(site),
                 ...(e.code ? { code: e.code } : {}),
-                ...(e.position ? { position: e.position } : {}),
+                ...(position ? { position } : {}),
                 ...(e.hint ? { hint: e.hint } : {}),
             });
             const extras = [];
-            if (e.position)
-                extras.push(`pos ${e.position}`);
+            if (position)
+                extras.push(`pos ${position}`);
             if (e.code)
                 extras.push(`code ${e.code}`);
             const tail = extras.length > 0 ? ` (${extras.join(", ")})` : "";
             err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}${tail}`);
             if (e.hint)
                 err(`      hint: ${e.hint}`);
-            err(`      query: ${snippet(query)}`);
+            err(`      query: ${snippet(site.query)}`);
         }
         else {
             diagnostics.push({
                 severity: "error",
                 phase: "describe",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query,
+                ...siteDiagnostic(site),
             });
             err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
-            err(`      query: ${snippet(query)}`);
+            err(`      query: ${snippet(site.query)}`);
         }
     }
     const allAttrRefs = [];
@@ -453,13 +472,10 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 severity: "error",
                 phase: "analyze",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query: r.query,
+                ...siteDiagnostic(site),
             });
             err(`  ✗ ${formatSite(site)} — analyze failed: ${e.message}`);
-            err(`      query: ${snippet(r.query)}`);
+            err(`      query: ${snippet(site.query)}`);
             continue;
         }
         try {
@@ -472,13 +488,10 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 severity: "error",
                 phase: "param-map",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query: r.query,
+                ...siteDiagnostic(site),
             });
             err(`  ✗ ${formatSite(site)} — paramMap failed: ${e.message}`);
-            err(`      query: ${snippet(r.query)}`);
+            err(`      query: ${snippet(site.query)}`);
         }
     }
     const dmlTablesToLoad = new Map();
@@ -534,11 +547,12 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             dmlBound: new Set(),
         };
         const entry = {
-            query: r.query,
+            query: r.sites[0].query,
             ...siteUsage(r.sites),
             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)),
+            ...(r.paramNames.length > 0 ? { paramNames: r.paramNames } : {}),
             columns: r.fields.map((f, i) => {
                 const parsed = parseColumnOverride(f.name);
                 const treatAsOverride = parsed.override !== undefined && isAliasOrExpression(f, schema);
@@ -575,12 +589,17 @@ 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;
-    if (input.reuseFunctions && functionCacheExists(opts.cacheDir)) {
+    if (userCfg.functionCatalog === false) {
+        functions = [];
+    }
+    else if (input.reuseFunctions && functionCacheExists(opts.cacheDir)) {
         functions = readFunctionCache(opts.cacheDir);
     }
     else {
         try {
-            functions = await introspectFunctions(client, schema);
+            functions = await introspectFunctions(client, schema, {
+                includeExtensionOwned: userCfg.functionCatalog?.includeExtensionOwned === true,
+            });
         }
         catch (error) {
             throw fatal("introspect", error);
@@ -658,10 +677,7 @@ export async function runPrepare(opts) {
                     severity: "error",
                     phase: "cache",
                     message: "query is not in the offline cache",
-                    file: site.file,
-                    line: site.line,
-                    column: site.column,
-                    query,
+                    ...siteDiagnostic(site),
                 });
                 if (!opts.json) {
                     console.error(`stale: ${formatSite(site)} — query not in cache`);