@onreza/sqlx-js 0.0.0

package/dist/src/commands/schema.js

@@ -0,0 +1,72 @@
+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";
+export async function applyShadowMigrations(databaseUrl, migrationsDir, log = console.log) {
+    const client = new PgClient(parseDatabaseUrl(databaseUrl));
+    await client.connect();
+    let locked = false;
+    let applied = 0;
+    try {
+        await acquireMigrateLock(client, DEFAULT_MIGRATE_LOCK_KEY);
+        locked = true;
+        const result = await applyPending(client, migrationsDir, (e) => {
+            if (e.kind === "applied") {
+                applied++;
+                log(`shadow: applied ${String(e.version).padStart(4, "0")}_${e.name}`);
+            }
+            else if (e.kind === "tampered") {
+                throw new Error(`sqlx-js shadow: ${e.version}_${e.name} hash mismatch (applied ${e.applied.slice(0, 16)} vs current ${e.current.slice(0, 16)})`);
+            }
+            else {
+                throw new Error(`sqlx-js shadow: ${e.version}_${e.name} failed — ${e.error}`);
+            }
+        });
+        if (applied === 0 && result.tampered === 0 && result.failed === 0)
+            log("shadow: migrations up-to-date");
+        return { applied };
+    }
+    finally {
+        if (locked) {
+            try {
+                await releaseMigrateLock(client, DEFAULT_MIGRATE_LOCK_KEY);
+            }
+            catch (e) {
+                log(`shadow: failed to release advisory lock: ${e.message}`);
+            }
+        }
+        await client.end();
+    }
+}
+function effectiveDatabaseUrl(opts) {
+    return opts.shadowUrl ?? opts.databaseUrl;
+}
+async function prepareShadowIfNeeded(opts) {
+    if (opts.shadowUrl)
+        await applyShadowMigrations(opts.shadowUrl, opts.migrationsDir);
+}
+export async function runSchemaDump(opts) {
+    await prepareShadowIfNeeded(opts);
+    const snapshot = await introspectDatabase(effectiveDatabaseUrl(opts));
+    writeSchemaSnapshot(opts.snapshotPath, snapshot);
+    if (opts.writeManifest)
+        writeSchemaManifest(opts.manifestPath, snapshot);
+    console.log(`schema: wrote ${opts.snapshotPath}`);
+    if (opts.writeManifest)
+        console.log(`schema: wrote ${opts.manifestPath}`);
+}
+export async function runSchemaCheck(opts) {
+    if (!schemaSnapshotExists(opts.snapshotPath)) {
+        console.error(`schema: missing snapshot ${opts.snapshotPath}`);
+        console.error("schema: run `sqlx-js schema dump` against a live database");
+        process.exit(1);
+    }
+    await prepareShadowIfNeeded(opts);
+    const expected = readSchemaSnapshot(opts.snapshotPath);
+    const actual = await introspectDatabase(effectiveDatabaseUrl(opts));
+    if (!schemaSnapshotEqual(expected, actual)) {
+        console.error(`schema: snapshot is stale: ${opts.snapshotPath}`);
+        console.error("schema: run `sqlx-js schema dump` and commit the updated snapshot");
+        process.exit(1);
+    }
+    console.log(`schema: ok — ${actual.relations.length} relation(s), ${actual.types.length} type(s), ${actual.functions.length} function(s)`);
+}

package/dist/src/commands/watch.d.ts

@@ -0,0 +1,21 @@
+import { openSession, prepareOnce, type PrepareOptions, type PrepareSession } from "./prepare.js";
+export type WatchPrepareHookResult = {
+    resetSession?: boolean;
+};
+export type WatchOptions = PrepareOptions & {
+    beforePrepare?: () => Promise<WatchPrepareHookResult | void>;
+};
+export type WatchState = {
+    session: PrepareSession | null;
+};
+type WatchDeps = {
+    openSession: typeof openSession;
+    prepareOnce: typeof prepareOnce;
+};
+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 runWatch(opts: WatchOptions): Promise<void>;
+export {};

package/dist/src/commands/watch.js

@@ -0,0 +1,94 @@
+import { watch as fsWatch } from "node:fs";
+import { basename } from "node:path";
+import { openSession, prepareOnce } from "./prepare.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 DEFAULT_DEPS = { openSession, prepareOnce };
+async function closeSession(session) {
+    if (!session)
+        return;
+    try {
+        await session.client.end();
+    }
+    catch { }
+}
+export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_DEPS) {
+    const hookResult = await opts.beforePrepare?.();
+    if (hookResult?.resetSession === true) {
+        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);
+}
+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 state = { session: null };
+    log("watch: initial prepare");
+    try {
+        const r = await prepareWatchedOnce(opts, state, log, err);
+        log(`watch: ready — ${r.entries} queries, ${r.failures} failures`);
+    }
+    catch (e) {
+        err(`watch: initial prepare failed — ${e.message}`);
+    }
+    log(`watch: monitoring ${opts.root}`);
+    let pending = false;
+    let running = null;
+    let timer = null;
+    const trigger = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(async () => {
+            timer = null;
+            if (running) {
+                pending = true;
+                return;
+            }
+            const start = Date.now();
+            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)`);
+                }
+                catch (e) {
+                    err(`watch: prepare error — ${e.message}`);
+                }
+            })();
+            await running;
+            running = null;
+            if (pending) {
+                pending = false;
+                trigger();
+            }
+        }, DEBOUNCE_MS);
+    };
+    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))
+            return;
+        trigger();
+    });
+    const shutdown = async () => {
+        console.log();
+        log("watch: stopping");
+        watcher.close();
+        await closeSession(state.session);
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => { });
+}

package/dist/src/config.d.ts

@@ -0,0 +1,6 @@
+export type SqlxJsConfig = {
+    jsonbTypes?: Record<string, string>;
+    customTypes?: Record<string, string>;
+};
+export declare function loadConfig(root: string): Promise<SqlxJsConfig>;
+export declare function lookupJsonbType(cfg: SqlxJsConfig, schema: string, table: string, column: string): string | undefined;

package/dist/src/config.js

@@ -0,0 +1,23 @@
+import { existsSync } 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"]) {
+        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`);
+        }
+        return cfg;
+    }
+    return {};
+}
+export function lookupJsonbType(cfg, schema, table, column) {
+    const types = cfg.jsonbTypes;
+    if (!types)
+        return undefined;
+    return (types[`${schema}.${table}.${column}`] ??
+        types[`${table}.${column}`]);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,23 @@
+import * as rt from "./postgres-runtime.js";
+import type { Typed as TypedFor, TypedFile as TypedFileFor, TypedSql as TypedSqlFor } from "./typed.js";
+export interface KnownQueries {
+}
+export interface KnownFileQueries {
+}
+export type { 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 } from "./runtime.js";
+export type { PostgresClient, PostgresOptions } 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 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 const close: typeof rt.close;
+export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+import * as rt from "./postgres-runtime.js";
+export { PgError, ConnectionLostError } from "./pg/wire.js";
+export { NoRowsError, TooManyRowsError } from "./runtime.js";
+export const sql = rt.sql;
+export const unsafe = rt.unsafe;
+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";

package/dist/src/pg/analyze.d.ts

@@ -0,0 +1,13 @@
+import type { FieldDescription } from "./wire.js";
+import type { SchemaCache } from "./schema.js";
+export type AnalysisResult = {
+    perColumnNullable: boolean[];
+    referencedTables: {
+        schema?: string;
+        name: string;
+    }[];
+    degraded?: {
+        reason: string;
+    };
+};
+export declare function analyzeQuery(sql: string, rowDesc: FieldDescription[], schema: SchemaCache): Promise<AnalysisResult>;