@onreza/sqlx-js 0.5.0 → 0.7.0

package/dist/src/commands/prepare.js

@@ -1,6 +1,6 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { PgClient, parseDatabaseUrl, PgError } from "../pg/wire.js";
 import { SchemaCache, compositeLiteral } from "../pg/schema.js";
 import { analyzeQuery } from "../pg/analyze.js";
@@ -9,11 +9,12 @@ 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";
 const JSON_OIDS = new Set([114, 3802]);
 const JSON_ARRAY_OIDS = new Set([199, 3807]);
 const JSON_INPUT_VALUE = 'import("@onreza/sqlx-js").JsonInputValue';
@@ -70,7 +71,8 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
         const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
-            const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
+            const table = resolvedTargetTable(target, schema);
+            const decl = column && table ? lookupJsonbType(cfg, table.schema, table.name, column) : undefined;
             if (decl)
                 return jsonParameter(decl);
         }
@@ -80,7 +82,8 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
         const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
-            const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
+            const table = resolvedTargetTable(target, schema);
+            const decl = column && table ? lookupJsonbType(cfg, table.schema, table.name, column) : undefined;
             if (decl)
                 return arrayParameter(jsonParameter(decl));
         }
@@ -102,6 +105,10 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
     }
     return resolveTs(paramOid, (oid) => schema.customType(oid));
 }
+function resolvedTargetTable(target, schema) {
+    const oid = schema.resolveTable(target.schema, target.table);
+    return oid === undefined ? undefined : schema.tableNameByOid(oid);
+}
 function resolveTargetColumn(target, schema) {
     if (target.column)
         return target.column;
@@ -148,6 +155,14 @@ 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;
@@ -187,6 +202,32 @@ 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) {
     let userCfg;
     try {
@@ -266,17 +307,23 @@ export async function describeAll(cfg, sessionClient, queries, concurrency) {
     }
     return results;
 }
-export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency()) {
+export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency(), input = {}) {
     let sites;
-    try {
-        sites = scanProject(opts.root, session.userCfg.scan);
+    if (input.sites) {
+        sites = input.sites;
     }
-    catch (error) {
-        throw fatal("scan", error);
+    else {
+        try {
+            sites = scanProject(opts.root, session.userCfg.scan);
+        }
+        catch (error) {
+            throw fatal("scan", error);
+        }
     }
     log(`scanned: found ${sites.length} sql() call site(s)`);
     const diagnostics = [];
     const cache = new Cache(opts.cacheDir);
+    let failures = 0;
     const unique = new Map();
     for (const s of sites) {
         const fp = fingerprint(s.query);
@@ -287,14 +334,50 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             unique.set(fp, { fp, query: s.query, sites: [s] });
     }
     const raw = [];
-    let failures = 0;
+    const reusedEntries = [];
+    const reusedGenerated = [];
     const { client, schema, userCfg } = session;
-    const describeList = [...unique.values()].map((u) => ({ fp: u.fp, query: u.query }));
+    const toPrepare = new Map();
+    for (const [fp, item] of unique) {
+        const cached = input.reuseCacheFps?.has(fp) ? cache.read(fp) : null;
+        if (!cached) {
+            toPrepare.set(fp, item);
+            continue;
+        }
+        const entry = { ...cached, ...siteUsage(item.sites) };
+        const entryDiagnostics = inferenceDiagnostics(entry, item.sites[0], opts.strictInference === true);
+        diagnostics.push(...entryDiagnostics);
+        if (opts.strictInference && entryDiagnostics.length > 0) {
+            failures++;
+            continue;
+        }
+        reusedEntries.push(entry);
+        reusedGenerated.push({ fp, entry });
+        log(`  ↺ ${formatSite(item.sites[0])} → reused ${entry.paramOids.length} param(s), ${entry.columns.length} col(s)`);
+    }
+    const describeList = [...toPrepare.values()].map((u) => ({ fp: u.fp, query: u.query }));
     const describeResults = await describeAll(parseDatabaseUrl(opts.databaseUrl), client, describeList, concurrency);
-    for (const { fp, query, sites: ss } of unique.values()) {
+    for (const { fp, query, sites: ss } of toPrepare.values()) {
         const site = ss[0];
         const outcome = describeResults.get(fp);
         if (outcome.ok) {
+            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;
         }
@@ -403,8 +486,8 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         for (const idx of pm.dmlBound) {
             const t = pm.targets.get(idx);
             if (t) {
-                const schema = t.schema ?? "public";
-                dmlTablesToLoad.set(JSON.stringify([schema, t.table]), { schema, name: t.table });
+                const key = JSON.stringify([t.schema ?? null, t.table]);
+                dmlTablesToLoad.set(key, t.schema ? { schema: t.schema, name: t.table } : { name: t.table });
             }
         }
     }
@@ -439,8 +522,8 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
     catch (error) {
         throw fatal("introspect", error);
     }
-    const entries = [];
-    const generated = [];
+    const entries = [...reusedEntries];
+    const generated = [...reusedGenerated];
     for (const r of raw) {
         if (failedFps.has(r.fp))
             continue;
@@ -470,6 +553,18 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             hasResultSet: r.fields.length > 0,
             ...(analysis.degraded ? { degraded: analysis.degraded } : {}),
         };
+        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;
@@ -480,11 +575,16 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         return { sites: sites.length, entries: entries.length, failures, pruned: 0, functions: 0, diagnostics };
     }
     let functions;
-    try {
-        functions = await introspectFunctions(client, schema);
+    if (input.reuseFunctions && functionCacheExists(opts.cacheDir)) {
+        functions = readFunctionCache(opts.cacheDir);
     }
-    catch (error) {
-        throw fatal("introspect", error);
+    else {
+        try {
+            functions = await introspectFunctions(client, schema);
+        }
+        catch (error) {
+            throw fatal("introspect", error);
+        }
     }
     let pruned;
     try {
@@ -516,7 +616,8 @@ export async function runPrepare(opts) {
             process.exitCode = 1;
         return;
     }
-    if (opts.check) {
+    if (opts.check || opts.offline) {
+        const mode = opts.offline ? "offline" : "check";
         let userCfg;
         try {
             userCfg = await loadConfig(opts.root);
@@ -573,9 +674,9 @@ export async function runPrepare(opts) {
                 console.log(JSON.stringify({
                     formatVersion: 1,
                     ok: false,
-                    mode: "check",
+                    mode,
                     sites: sites.length,
-                    entries: unique.size - diagnostics.length,
+                    entries: [...unique.keys()].filter((fp) => cache.has(fp)).length,
                     failures: diagnostics.length,
                     pruned: 0,
                     functions: 0,
@@ -583,20 +684,83 @@ 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;
         }
-        let entries;
+        const entries = [];
+        let inferenceFailures = 0;
         let functions;
         try {
-            entries = [...unique.values()].map((u) => {
+            for (const u of unique.values()) {
                 const entry = cache.read(u.fp);
-                return entry ? { ...entry, ...siteUsage(u.sites) } : null;
-            }).filter((e) => e !== null);
+                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);
-            emitDts(opts.dtsPath, entries, functions);
+            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,
+                        sites: sites.length,
+                        entries: entries.length,
+                        failures: inferenceFailures,
+                        pruned: 0,
+                        functions: functions.length,
+                        diagnostics,
+                    }, null, 2));
+                }
+                else {
+                    for (const diagnostic of diagnostics) {
+                        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;
+            }
+            if (opts.offline)
+                emitDts(opts.dtsPath, entries, functions);
         }
         catch (error) {
             throw fatal("cache", error);
@@ -605,17 +769,21 @@ export async function runPrepare(opts) {
             console.log(JSON.stringify({
                 formatVersion: 1,
                 ok: true,
-                mode: "check",
+                mode,
                 sites: sites.length,
                 entries: entries.length,
                 failures: 0,
                 pruned: 0,
                 functions: functions.length,
-                diagnostics: [],
+                diagnostics,
             }, null, 2));
         }
         else {
-            console.log(`ok — ${entries.length} unique queries, ${functions.length} function(s), types regenerated`);
+            for (const diagnostic of diagnostics) {
+                console.error(`inference warning: ${diagnostic.file}:${diagnostic.line}:${diagnostic.column} — ${diagnostic.message}`);
+            }
+            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/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,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 {};