@onreza/sqlx-js 0.4.0 → 0.6.0

package/dist/src/commands/watch.js

@@ -1,9 +1,28 @@
 import { watch as fsWatch } from "node:fs";
 import { basename } from "node:path";
 import { openSession, prepareOnce } from "./prepare.js";
+import { configHash, loadConfig } from "../config.js";
 const EXT_RE = /\.(ts|tsx|mts|cts|sql)$/;
 const SKIP_DIRS = ["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"];
 const DEBOUNCE_MS = 150;
+const CONFIG_FILES = new Set([
+    "sqlx-js.config.ts",
+    "sqlx-js.config.mts",
+    "sqlx-js.config.js",
+    "sqlx-js.config.mjs",
+]);
+export function shouldWatchFile(filename) {
+    const file = filename.replace(/\\/g, "/");
+    if (SKIP_DIRS.some((dir) => file === dir || file.startsWith(`${dir}/`) || file.includes(`/${dir}/`))) {
+        return false;
+    }
+    const base = basename(file);
+    if (base === "sqlx-js-env.d.ts" || base === "sqlx-js.d.ts")
+        return false;
+    if (CONFIG_FILES.has(base) || /^tsconfig(?:\.[^.]+)*\.json$/.test(base))
+        return true;
+    return EXT_RE.test(file);
+}
 const DEFAULT_DEPS = { openSession, prepareOnce };
 async function closeSession(session) {
     if (!session)
@@ -15,7 +34,9 @@ async function closeSession(session) {
 }
 export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_DEPS) {
     const hookResult = await opts.beforePrepare?.();
-    if (hookResult?.resetSession === true) {
+    const currentConfig = await loadConfig(opts.root);
+    if (hookResult?.resetSession === true ||
+        (state.session !== null && configHash(state.session.userCfg) !== configHash(currentConfig))) {
         await closeSession(state.session);
         state.session = null;
     }
@@ -70,14 +91,7 @@ export async function runWatch(opts) {
     const watcher = fsWatch(opts.root, { recursive: true }, (_event, filename) => {
         if (!filename)
             return;
-        const raw = filename.toString();
-        const f = raw.replace(/\\/g, "/");
-        if (SKIP_DIRS.some((d) => f === d || f.startsWith(`${d}/`) || f.includes(`/${d}/`)))
-            return;
-        const base = basename(f);
-        if (base === "sqlx-js-env.d.ts" || base === "sqlx-js.d.ts")
-            return;
-        if (!EXT_RE.test(f))
+        if (!shouldWatchFile(filename.toString()))
             return;
         trigger();
     });

package/dist/src/config.d.ts

@@ -1,6 +1,12 @@
+export type ScanConfig = {
+    include?: string[];
+    exclude?: string[];
+    modules?: string[];
+};
 export type SqlxJsConfig = {
     jsonbTypes?: Record<string, string>;
     customTypes?: Record<string, string>;
+    scan?: ScanConfig;
     schema?: {
         provider?: "builtin" | "pgschema";
         file?: string;
@@ -8,5 +14,21 @@ export type SqlxJsConfig = {
         command?: string;
     };
 };
+export declare function defineConfig<T extends SqlxJsConfig>(config: T): T;
+export declare function loadRootEnv(root: string): string | undefined;
+export declare function configPath(root: string): string | undefined;
 export declare function loadConfig(root: string): Promise<SqlxJsConfig>;
+export declare function prepareConfigHash(cfg: SqlxJsConfig): string;
+export declare function configHash(cfg: SqlxJsConfig): string;
+export declare function loadConfigInfo(root: string): Promise<{
+    config: SqlxJsConfig;
+    path?: string;
+}>;
+export declare function assertSupportedRuntime(): void;
+export declare function runtimeVersion(): {
+    runtime: "node" | "bun";
+    version: string;
+};
+export declare function nativeTypeScriptEnabled(): boolean | string;
+export declare function envFilePath(root: string): string;
 export declare function lookupJsonbType(cfg: SqlxJsConfig, schema: string, table: string, column: string): string | undefined;

package/dist/src/config.js

@@ -1,18 +1,156 @@
-import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-export async function loadConfig(root) {
-    for (const name of ["sqlx-js.config.ts", "sqlx-js.config.js", "sqlx-js.config.mjs"]) {
+import { pathToFileURL } from "node:url";
+import { parseEnv } from "node:util";
+export function defineConfig(config) {
+    return config;
+}
+export function loadRootEnv(root) {
+    const path = join(root, ".env");
+    if (!existsSync(path))
+        return undefined;
+    const parsed = parseEnv(readFileSync(path, "utf8"));
+    for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === undefined)
+            process.env[key] = value;
+    }
+    return path;
+}
+export function configPath(root) {
+    for (const name of ["sqlx-js.config.mts", "sqlx-js.config.ts", "sqlx-js.config.mjs", "sqlx-js.config.js"]) {
         const p = join(root, name);
-        if (!existsSync(p))
-            continue;
-        const mod = await import(p);
-        const cfg = (mod.default ?? mod);
-        if (typeof cfg !== "object" || cfg === null) {
-            throw new Error(`sqlx-js: ${name} must default-export a config object`);
+        if (existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+export async function loadConfig(root) {
+    const path = configPath(root);
+    if (!path)
+        return {};
+    const url = pathToFileURL(path);
+    url.searchParams.set("mtime", String(statSync(path).mtimeMs));
+    const mod = await import(url.href);
+    if (!("default" in mod)) {
+        throw new Error(`sqlx-js: ${path} must default-export a config object`);
+    }
+    return validateConfig(mod.default, path);
+}
+function validateStringRecord(value, name, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`sqlx-js: ${path} ${name} must be an object of string values`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item !== "string") {
+            throw new Error(`sqlx-js: ${path} ${name}.${key} must be a string`);
         }
-        return cfg;
     }
-    return {};
+}
+function validateStringArray(value, name, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        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`);
+    }
+    const config = value;
+    if (config.jsonbTypes !== undefined)
+        validateStringRecord(config.jsonbTypes, "jsonbTypes", path);
+    if (config.customTypes !== undefined)
+        validateStringRecord(config.customTypes, "customTypes", path);
+    if (config.scan !== undefined) {
+        if (!config.scan || typeof config.scan !== "object" || Array.isArray(config.scan)) {
+            throw new Error(`sqlx-js: ${path} scan must be an object`);
+        }
+        const scan = config.scan;
+        if (scan.include !== undefined)
+            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)) {
+            throw new Error(`sqlx-js: ${path} schema must be an object`);
+        }
+        const schema = config.schema;
+        if (schema.provider !== undefined && schema.provider !== "builtin" && schema.provider !== "pgschema") {
+            throw new Error(`sqlx-js: ${path} schema.provider must be builtin or pgschema`);
+        }
+        for (const key of ["file", "command"]) {
+            if (schema[key] !== undefined && typeof schema[key] !== "string") {
+                throw new Error(`sqlx-js: ${path} schema.${key} must be a string`);
+            }
+        }
+        if (schema.schemas !== undefined)
+            validateStringArray(schema.schemas, "schema.schemas", path);
+    }
+    return value;
+}
+export function prepareConfigHash(cfg) {
+    const value = stableValue({
+        jsonbTypes: cfg.jsonbTypes ?? {},
+        customTypes: cfg.customTypes ?? {},
+    });
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
+}
+export function configHash(cfg) {
+    return createHash("sha256").update(JSON.stringify(stableValue(cfg))).digest("hex").slice(0, 16);
+}
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, item]) => [key, stableValue(item)]));
+}
+export async function loadConfigInfo(root) {
+    const path = configPath(root);
+    if (!path)
+        return { config: {} };
+    return { config: await loadConfig(root), path };
+}
+export function assertSupportedRuntime() {
+    const bun = process.versions.bun;
+    if (bun) {
+        if (majorMinorLessThan(bun, 1, 3)) {
+            throw new Error(`sqlx-js requires Bun >=1.3, current ${bun}`);
+        }
+        return;
+    }
+    const node = process.versions.node;
+    if (majorMinorLessThan(node, 24, 0)) {
+        throw new Error(`sqlx-js requires Node.js >=24, current ${node}`);
+    }
+}
+function majorMinorLessThan(version, minMajor, minMinor) {
+    const [major = 0, minor = 0] = version.split(".").map(Number);
+    return major < minMajor || (major === minMajor && minor < minMinor);
+}
+export function runtimeVersion() {
+    if (process.versions.bun)
+        return { runtime: "bun", version: process.versions.bun };
+    return { runtime: "node", version: process.versions.node };
+}
+export function nativeTypeScriptEnabled() {
+    if (process.versions.bun)
+        return true;
+    return process.features.typescript;
+}
+export function envFilePath(root) {
+    return join(root, ".env");
 }
 export function lookupJsonbType(cfg, schema, table, column) {
     const types = cfg.jsonbTypes;

package/dist/src/index.d.ts

@@ -18,11 +18,13 @@ export type JsonInputObject = {
     readonly [key: string]: JsonInputValue | undefined;
 };
 export type JsonInputArray = readonly JsonInputValue[];
-export type { SqlxJsConfig } from "./config.js";
+export { defineConfig } from "./config.js";
+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 { 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>;
@@ -34,4 +36,4 @@ export declare const getClient: typeof rt.getClient;
 export declare const setClient: typeof rt.setClient;
 export declare const createClient: typeof rt.createClient;
 export declare const close: typeof rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";
+export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

package/dist/src/index.js

@@ -1,4 +1,5 @@
 import * as rt from "./postgres-runtime.js";
+export { defineConfig } from "./config.js";
 export { PgError, ConnectionLostError } from "./pg/wire.js";
 export { NoRowsError, TooManyRowsError } from "./runtime.js";
 export const sql = rt.sql;
@@ -7,4 +8,4 @@ export const getClient = rt.getClient;
 export const setClient = rt.setClient;
 export const createClient = rt.createClient;
 export const close = rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";
+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 {};