@onreza/sqlx-js 0.5.0 → 0.7.0

package/dist/src/commands/watch.js

@@ -1,7 +1,9 @@
-import { watch as fsWatch } from "node:fs";
-import { basename } from "node:path";
-import { openSession, prepareOnce } from "./prepare.js";
+import { existsSync, watch as fsWatch } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { openSession, prepareOnce, PrepareFatalError, } from "./prepare.js";
 import { configHash, loadConfig } from "../config.js";
+import { fingerprint } from "../cache.js";
+import { findSourceFiles, scanFile, scanProject } from "../scan/scanner.js";
 const EXT_RE = /\.(ts|tsx|mts|cts|sql)$/;
 const SKIP_DIRS = ["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"];
 const DEBOUNCE_MS = 150;
@@ -23,7 +25,25 @@ export function shouldWatchFile(filename) {
         return true;
     return EXT_RE.test(file);
 }
-const DEFAULT_DEPS = { openSession, prepareOnce };
+export function formatWatchEvent(name, data = {}, timestamp = new Date().toISOString()) {
+    return JSON.stringify({ formatVersion: 1, event: name, timestamp, ...data });
+}
+export function watchErrorData(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!(error instanceof PrepareFatalError))
+        return { message };
+    return {
+        diagnostic: {
+            severity: "error",
+            phase: error.phase,
+            message,
+            ...(error.file === undefined ? {} : { file: error.file }),
+            ...(error.line === undefined ? {} : { line: error.line }),
+            ...(error.column === undefined ? {} : { column: error.column }),
+        },
+    };
+}
+const DEFAULT_DEPS = { openSession, prepareOnce, loadConfig, scanProject, scanFile, findSourceFiles };
 async function closeSession(session) {
     if (!session)
         return;
@@ -32,35 +52,164 @@ async function closeSession(session) {
     }
     catch { }
 }
-export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_DEPS) {
+export async function prepareWatchedOnce(opts, state, log, err, deps = {}, changedFiles = []) {
+    const active = { ...DEFAULT_DEPS, ...deps };
     const hookResult = await opts.beforePrepare?.();
-    const currentConfig = await loadConfig(opts.root);
-    if (hookResult?.resetSession === true ||
-        (state.session !== null && configHash(state.session.userCfg) !== configHash(currentConfig))) {
+    const currentConfig = await active.loadConfig(opts.root);
+    const configChanged = state.session !== null && configHash(state.session.userCfg) !== configHash(currentConfig);
+    const resetSession = hookResult?.resetSession === true || configChanged;
+    if (resetSession) {
         await closeSession(state.session);
         state.session = null;
     }
     if (!state.session)
-        state.session = await deps.openSession(opts);
-    return await deps.prepareOnce(opts, state.session, log, err, 1);
+        state.session = await active.openSession(opts);
+    const full = resetSession || !state.sitesByFile || changedFiles.some(isProjectGraphFile);
+    let nextSites;
+    let changedFps = new Set();
+    if (full) {
+        const sites = active.scanProject(opts.root, currentConfig.scan);
+        nextSites = groupSites(sites);
+        changedFps = new Set(sites.map((site) => fingerprint(site.query)));
+    }
+    else {
+        const previousSites = state.sitesByFile;
+        const dirtyFiles = state.dirtyFiles ?? new Set();
+        const requested = new Set([...changedFiles, ...dirtyFiles].map((file) => projectPath(opts.root, file)));
+        const affectedSources = new Set();
+        for (const changed of requested) {
+            if (/\.(ts|tsx|mts|cts)$/.test(changed))
+                affectedSources.add(changed);
+            if (changed.endsWith(".sql")) {
+                for (const [source, sites] of previousSites) {
+                    if (sites.some((site) => site.sqlFilePath && projectPath(opts.root, site.sqlFilePath) === changed)) {
+                        affectedSources.add(source);
+                    }
+                }
+            }
+        }
+        nextSites = new Map(previousSites);
+        const allowed = new Set(active.findSourceFiles(opts.root, currentConfig.scan).map((file) => projectPath(opts.root, file)));
+        for (const source of nextSites.keys()) {
+            if (!allowed.has(source))
+                affectedSources.add(source);
+        }
+        try {
+            for (const source of affectedSources) {
+                const previous = nextSites.get(source) ?? [];
+                for (const site of previous)
+                    changedFps.add(fingerprint(site.query));
+                const absolute = resolve(opts.root, source);
+                if (!existsSync(absolute) || !allowed.has(source)) {
+                    nextSites.delete(source);
+                    continue;
+                }
+                const scanned = active.scanFile(absolute, opts.root, currentConfig.scan?.modules);
+                if (scanned.length > 0)
+                    nextSites.set(source, scanned);
+                else
+                    nextSites.delete(source);
+                for (const site of scanned)
+                    changedFps.add(fingerprint(site.query));
+            }
+            for (const source of affectedSources)
+                dirtyFiles.delete(source);
+        }
+        catch (error) {
+            for (const source of affectedSources)
+                dirtyFiles.add(source);
+            state.dirtyFiles = dirtyFiles;
+            throw error;
+        }
+        state.dirtyFiles = dirtyFiles;
+    }
+    const sites = [...nextSites.values()].flat();
+    const dirtyFps = state.dirtyFps ?? new Set();
+    const reuseCacheFps = new Set(sites
+        .map((site) => fingerprint(site.query))
+        .filter((fp) => !changedFps.has(fp) && !dirtyFps.has(fp)));
+    const result = await active.prepareOnce(opts, state.session, log, err, 1, {
+        sites,
+        reuseCacheFps,
+        reuseFunctions: !full,
+    });
+    state.sitesByFile = nextSites;
+    if (result.failures === 0) {
+        state.dirtyFps = new Set();
+    }
+    else {
+        state.dirtyFps = new Set([...dirtyFps, ...changedFps]);
+    }
+    return result;
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function projectPath(root, path) {
+    return normalizePath(relative(resolve(root), resolve(root, path)));
+}
+function isProjectGraphFile(path) {
+    const base = basename(path);
+    return CONFIG_FILES.has(base) || /^tsconfig(?:\.[^.]+)*\.json$/.test(base);
+}
+function groupSites(sites) {
+    const grouped = new Map();
+    for (const site of sites) {
+        const file = normalizePath(site.file);
+        const current = grouped.get(file) ?? [];
+        current.push(site);
+        grouped.set(file, current);
+    }
+    return grouped;
 }
 export async function runWatch(opts) {
     const stamp = () => new Date().toTimeString().slice(0, 8);
-    const log = (m) => console.log(`[${stamp()}] ${m}`);
-    const err = (m) => console.error(`[${stamp()}] ${m}`);
+    const event = (name, data = {}) => {
+        console.log(formatWatchEvent(name, data));
+    };
+    const log = opts.jsonl ? () => { } : (m) => console.log(`[${stamp()}] ${m}`);
+    const err = opts.jsonl ? () => { } : (m) => console.error(`[${stamp()}] ${m}`);
     const state = { session: null };
-    log("watch: initial prepare");
+    const report = (result, durationMs) => {
+        if (!opts.jsonl)
+            return;
+        for (const diagnostic of result.diagnostics)
+            event("diagnostic", { diagnostic });
+        event("prepared", {
+            ok: result.failures === 0,
+            sites: result.sites,
+            entries: result.entries,
+            failures: result.failures,
+            pruned: result.pruned,
+            functions: result.functions,
+            ...(durationMs === undefined ? {} : { durationMs }),
+        });
+    };
+    if (opts.jsonl)
+        event("start", { root: opts.root });
+    else
+        log("watch: initial prepare");
     try {
         const r = await prepareWatchedOnce(opts, state, log, err);
-        log(`watch: ready — ${r.entries} queries, ${r.failures} failures`);
+        if (opts.jsonl)
+            report(r);
+        else
+            log(`watch: ready — ${r.entries} queries, ${r.failures} failures`);
     }
     catch (e) {
-        err(`watch: initial prepare failed — ${e.message}`);
+        if (opts.jsonl)
+            event("error", watchErrorData(e));
+        else
+            err(`watch: initial prepare failed — ${e.message}`);
     }
-    log(`watch: monitoring ${opts.root}`);
+    if (opts.jsonl)
+        event("watching", { root: opts.root });
+    else
+        log(`watch: monitoring ${opts.root}`);
     let pending = false;
     let running = null;
     let timer = null;
+    const changedFiles = new Set();
     const trigger = () => {
         if (timer)
             clearTimeout(timer);
@@ -71,13 +220,22 @@ export async function runWatch(opts) {
                 return;
             }
             const start = Date.now();
+            const batch = [...changedFiles];
+            changedFiles.clear();
             running = (async () => {
                 try {
-                    const r = await prepareWatchedOnce(opts, state, log, err);
-                    log(`watch: re-prepared in ${Date.now() - start}ms (${r.entries} queries, ${r.failures} failures)`);
+                    const r = await prepareWatchedOnce(opts, state, log, err, {}, batch);
+                    const durationMs = Date.now() - start;
+                    if (opts.jsonl)
+                        report(r, durationMs);
+                    else
+                        log(`watch: re-prepared in ${durationMs}ms (${r.entries} queries, ${r.failures} failures)`);
                 }
                 catch (e) {
-                    err(`watch: prepare error — ${e.message}`);
+                    if (opts.jsonl)
+                        event("error", watchErrorData(e));
+                    else
+                        err(`watch: prepare error — ${e.message}`);
                 }
             })();
             await running;
@@ -93,11 +251,16 @@ export async function runWatch(opts) {
             return;
         if (!shouldWatchFile(filename.toString()))
             return;
+        changedFiles.add(normalizePath(filename.toString()));
         trigger();
     });
     const shutdown = async () => {
-        console.log();
-        log("watch: stopping");
+        if (opts.jsonl)
+            event("stopping");
+        else {
+            console.log();
+            log("watch: stopping");
+        }
         watcher.close();
         await closeSession(state.session);
         process.exit(0);

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/function-cache.d.ts

@@ -14,5 +14,7 @@ export type FunctionEntry = {
     returns: string;
     returnsSet: boolean;
 };
+export declare function functionCachePath(cacheDir: string): string;
+export declare function functionCacheExists(cacheDir: string): boolean;
 export declare function readFunctionCache(cacheDir: string): FunctionEntry[];
 export declare function writeFunctionCache(cacheDir: string, functions: FunctionEntry[]): void;

package/dist/src/function-cache.js

@@ -1,9 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
-function cachePath(cacheDir) {
+export function functionCachePath(cacheDir) {
     return join(cacheDir, "functions", "functions.json");
 }
+export function functionCacheExists(cacheDir) {
+    return existsSync(functionCachePath(cacheDir));
+}
 function parseFunctionCache(raw) {
     if (!raw || typeof raw !== "object")
         return [];
@@ -13,14 +16,14 @@ function parseFunctionCache(raw) {
     return obj.functions;
 }
 export function readFunctionCache(cacheDir) {
-    const path = cachePath(cacheDir);
+    const path = functionCachePath(cacheDir);
     if (!existsSync(path))
         return [];
     const text = readFileSync(path, "utf8");
     return parseFunctionCache(JSON.parse(text));
 }
 export function writeFunctionCache(cacheDir, functions) {
-    const path = cachePath(cacheDir);
+    const path = functionCachePath(cacheDir);
     mkdirSync(dirname(path), { recursive: true });
     const payload = { version: 1, functions };
     const tmp = `${path}.tmp-${randomBytes(4).toString("hex")}`;

package/dist/src/index.d.ts

@@ -23,17 +23,33 @@ export type { ScanConfig, SqlxJsConfig } from "./config.js";
 export type { SslMode, ConnConfig } from "./pg/wire.js";
 export { PgError, ConnectionLostError } from "./pg/wire.js";
 export { NoRowsError, TooManyRowsError } from "./runtime.js";
-export type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook } from "./runtime.js";
+export type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook, OnQueryHookError } from "./runtime.js";
 export type { ExecuteResult, JsonParameter, PgArrayParameter } from "./runtime.js";
 export type { PostgresClient, PostgresOptions, CreateClientOptions } from "./postgres-runtime.js";
 export type TypedFile = TypedFileFor<KnownFileQueries>;
 export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
 export type Typed = TypedFor<KnownQueries, KnownFileQueries, import("./runtime.js").TransactionOptions>;
+export type QueryRegistry = {
+    queries: object;
+    fileQueries: object;
+};
+export interface DefaultQueryRegistry {
+    queries: KnownQueries;
+    fileQueries: KnownFileQueries;
+    functions: KnownFunctions;
+}
+export type SqlClient<Registry extends QueryRegistry = DefaultQueryRegistry> = {
+    sql: TypedFor<Registry["queries"], Registry["fileQueries"], import("./runtime.js").TransactionOptions>;
+    unsafe: Unsafe;
+    client: import("./postgres-runtime.js").PostgresClient;
+    close: () => Promise<void>;
+};
 export declare const sql: Typed;
 export type Unsafe = (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
 export declare const unsafe: Unsafe;
 export declare const getClient: typeof rt.getClient;
 export declare const setClient: typeof rt.setClient;
 export declare const createClient: typeof rt.createClient;
+export declare function createSqlClient<Registry extends QueryRegistry = DefaultQueryRegistry>(url?: string, options?: import("./postgres-runtime.js").CreateClientOptions): SqlClient<Registry>;
 export declare const close: typeof rt.close;
 export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

package/dist/src/index.js

@@ -7,5 +7,8 @@ export const unsafe = rt.unsafe;
 export const getClient = rt.getClient;
 export const setClient = rt.setClient;
 export const createClient = rt.createClient;
+export function createSqlClient(url, options) {
+    return rt.createSqlClient(url, options);
+}
 export const close = rt.close;
 export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

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