@onreza/sqlx-js 0.6.0 → 0.8.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,12 +9,13 @@ 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";
 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';
@@ -71,7 +72,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 +83,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 +106,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;
@@ -201,8 +208,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)) {
@@ -219,7 +227,7 @@ function inferenceDiagnostics(entry, site, strict) {
         file: site.file,
         line: site.line,
         column: site.column,
-        query: entry.query,
+        query: site.query,
     }));
 }
 export async function openSession(opts) {
@@ -301,32 +309,58 @@ 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 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 = [];
-    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) {
@@ -341,18 +375,19 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                     file: site.file,
                     line: site.line,
                     column: site.column,
-                    query,
+                    query: site.query,
                 });
                 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",
@@ -360,21 +395,21 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 file: site.file,
                 line: site.line,
                 column: site.column,
-                query,
+                query: site.query,
                 ...(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({
@@ -384,10 +419,10 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 file: site.file,
                 line: site.line,
                 column: site.column,
-                query,
+                query: site.query,
             });
             err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
-            err(`      query: ${snippet(query)}`);
+            err(`      query: ${snippet(site.query)}`);
         }
     }
     const allAttrRefs = [];
@@ -425,10 +460,10 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 file: site.file,
                 line: site.line,
                 column: site.column,
-                query: r.query,
+                query: site.query,
             });
             err(`  ✗ ${formatSite(site)} — analyze failed: ${e.message}`);
-            err(`      query: ${snippet(r.query)}`);
+            err(`      query: ${snippet(site.query)}`);
             continue;
         }
         try {
@@ -444,10 +479,10 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 file: site.file,
                 line: site.line,
                 column: site.column,
-                query: r.query,
+                query: site.query,
             });
             err(`  ✗ ${formatSite(site)} — paramMap failed: ${e.message}`);
-            err(`      query: ${snippet(r.query)}`);
+            err(`      query: ${snippet(site.query)}`);
         }
     }
     const dmlTablesToLoad = new Map();
@@ -455,8 +490,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 +526,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;
@@ -503,11 +538,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);
@@ -544,11 +580,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 +621,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 +679,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 +689,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 +712,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 +755,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 +774,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 +787,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 {};