@onreza/sqlx-js 0.5.0 → 0.6.0

package/dist/src/commands/prepare.js

@@ -14,6 +14,7 @@ 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';
@@ -148,6 +149,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 +196,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 {
@@ -295,6 +330,23 @@ 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;
         }
@@ -470,6 +522,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;
@@ -588,14 +652,46 @@ export async function runPrepare(opts) {
             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);
+            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) {
@@ -611,10 +707,13 @@ export async function runPrepare(opts) {
                 failures: 0,
                 pruned: 0,
                 functions: functions.length,
-                diagnostics: [],
+                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`);
         }
         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/config.d.ts

@@ -1,6 +1,7 @@
 export type ScanConfig = {
     include?: string[];
     exclude?: string[];
+    modules?: string[];
 };
 export type SqlxJsConfig = {
     jsonbTypes?: Record<string, string>;

package/dist/src/config.js

@@ -52,6 +52,12 @@ function validateStringArray(value, name, path) {
         throw new Error(`sqlx-js: ${path} ${name} must be an array of strings`);
     }
 }
+function validateModuleArray(value, path) {
+    validateStringArray(value, "scan.modules", path);
+    if (value.length === 0 || value.some((item) => item.trim() === "")) {
+        throw new Error(`sqlx-js: ${path} scan.modules must contain at least one non-empty module name`);
+    }
+}
 function validateConfig(value, path) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error(`sqlx-js: ${path} must default-export a config object`);
@@ -70,6 +76,8 @@ function validateConfig(value, path) {
             validateStringArray(scan.include, "scan.include", path);
         if (scan.exclude !== undefined)
             validateStringArray(scan.exclude, "scan.exclude", path);
+        if (scan.modules !== undefined)
+            validateModuleArray(scan.modules, path);
     }
     if (config.schema !== undefined) {
         if (!config.schema || typeof config.schema !== "object" || Array.isArray(config.schema)) {

package/dist/src/migration-core.d.ts

@@ -0,0 +1,157 @@
+import { PgClient } from "./pg/wire.js";
+export type MigrationFile = {
+    version: number;
+    name: string;
+    upPath: string;
+    downPath: string | null;
+    upSql: string;
+    upHash: string;
+    squash: SquashMetadata | null;
+};
+export type SquashReplacement = {
+    version: number;
+    name: string;
+    upHash: string;
+};
+export type SquashMetadata = {
+    format: 1;
+    replaces: SquashReplacement[];
+};
+export type MigrationStore = {
+    table: string;
+};
+export declare const SQUASH_PREFIX = "-- sqlx-js-squash:";
+export declare const DEFAULT_MIGRATE_LOCK_KEY = 18750938867203960n;
+export declare function readMigrations(dir: string): MigrationFile[];
+export declare function parseSquashMetadata(sql: string): SquashMetadata | null;
+export declare function ensureTable(client: PgClient): Promise<MigrationStore>;
+export declare function listApplied(client: PgClient, store?: MigrationStore): Promise<Map<number, {
+    name: string;
+    hash: string;
+}>>;
+export type ApplyOutcome = {
+    kind: "applied";
+    version: number;
+    name: string;
+} | {
+    kind: "adopted";
+    version: number;
+    name: string;
+    replaced: number;
+} | {
+    kind: "tampered";
+    version: number;
+    name: string;
+    applied: string;
+    current: string;
+} | {
+    kind: "failed";
+    version: number;
+    name: string;
+    error: string;
+};
+export type PlanOutcome = {
+    kind: "pending";
+    version: number;
+    name: string;
+} | {
+    kind: "adoptable";
+    version: number;
+    name: string;
+    replaced: number;
+} | {
+    kind: "tampered";
+    version: number;
+    name: string;
+    applied: string;
+    current: string;
+} | {
+    kind: "failed";
+    version: number;
+    name: string;
+    error: string;
+};
+export type MigrationPlanItem = {
+    kind: "apply";
+    version: number;
+    name: string;
+} | {
+    kind: "adopt";
+    version: number;
+    name: string;
+    replaced: number;
+};
+export type MigrationPlanDiagnostic = Extract<PlanOutcome, {
+    kind: "tampered" | "failed";
+}>;
+export type MigrationPlanSnapshot = {
+    ok: boolean;
+    pending: number;
+    adoptable: number;
+    tampered: number;
+    failed: number;
+    steps: MigrationPlanItem[];
+    diagnostics: MigrationPlanDiagnostic[];
+};
+export type MigrationInfoStatus = "applied" | "pending" | "adoptable" | "superseded" | "tampered" | "failed";
+export type MigrationInfoItem = {
+    version: number;
+    name: string;
+    status: MigrationInfoStatus;
+    detail?: string;
+};
+export type MigrationInfoSnapshot = {
+    historyTable: string | null;
+    summary: Record<MigrationInfoStatus, number>;
+    items: MigrationInfoItem[];
+};
+type InternalMigrationPlanItem = {
+    kind: "apply";
+    migration: MigrationFile;
+} | {
+    kind: "adopt";
+    migration: MigrationFile;
+    replaced: number;
+};
+export type MigrationValidationOutcome = {
+    kind: "tampered";
+    version: number;
+    name: string;
+    applied: string;
+    current: string;
+} | {
+    kind: "failed";
+    version: number;
+    name: string;
+    error: string;
+};
+export declare function effectiveSquashReplacements(all: MigrationFile[]): SquashReplacement[];
+export declare function buildMigrationPlan(all: MigrationFile[], applied: Map<number, {
+    name: string;
+    hash: string;
+}>, onEvent?: (event: MigrationValidationOutcome) => void): {
+    kind: "ok";
+    steps: InternalMigrationPlanItem[];
+} | {
+    kind: "failed";
+} | {
+    kind: "tampered";
+};
+export declare function resetMigrationSession(client: PgClient): Promise<void>;
+export declare function planPending(client: PgClient, migrationsDir: string, onEvent?: (event: PlanOutcome) => void): Promise<{
+    pending: number;
+    adoptable: number;
+    tampered: number;
+    failed: number;
+    steps: MigrationPlanItem[];
+}>;
+export declare function inspectMigrationPlan(client: PgClient, migrationsDir: string): Promise<MigrationPlanSnapshot>;
+export declare function inspectMigrations(client: PgClient, migrationsDir: string): Promise<MigrationInfoSnapshot>;
+export declare function applyPending(client: PgClient, migrationsDir: string, onEvent?: (event: ApplyOutcome) => void): Promise<{
+    applied: number;
+    tampered: number;
+    failed: number;
+}>;
+export declare function acquireMigrateLock(client: PgClient, lockKey?: number | bigint, timeoutMs?: number): Promise<void>;
+export declare function releaseMigrateLock(client: PgClient, lockKey?: number | bigint): Promise<void>;
+export {};