@onreza/sqlx-js 0.4.0 → 0.6.0

package/dist/src/commands/migrate.js

@@ -4,79 +4,12 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 import { PgClient, parseDatabaseUrl, decodeText } from "../pg/wire.js";
-import { openSession, prepareOnce } from "./prepare.js";
+import { DEFAULT_MIGRATE_LOCK_KEY, SQUASH_PREFIX, acquireMigrateLock, applyPending, buildMigrationPlan, effectiveSquashReplacements, ensureTable, inspectMigrationPlan, inspectMigrations, listApplied, parseSquashMetadata, planPending, readMigrations, releaseMigrateLock, resetMigrationSession, } from "../migration-core.js";
 import { introspectConnected, schemaSnapshotEqual, } from "../schema-snapshot.js";
-const SQUASH_PREFIX = "-- sqlx-js-squash:";
-export const DEFAULT_MIGRATE_LOCK_KEY = 18750938867203960n;
+export * from "../migration-core.js";
 const FILE_RE = /^(\d+)_(.+)\.up\.sql$/;
 const DOWN_FILE_RE = /^(\d+)_(.+)\.down\.sql$/;
 const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-const MIGRATIONS_TABLE = "_sqlx_js_migrations";
-function readMigrations(dir) {
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    for (const f of readdirSync(dir).sort()) {
-        const m = FILE_RE.exec(f);
-        if (!m)
-            continue;
-        const version = parseInt(m[1], 10);
-        const name = m[2];
-        if (!SAFE_NAME_RE.test(name)) {
-            throw new Error(`sqlx-js.migrate: unsafe migration filename ${f} — name must match /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/`);
-        }
-        const upPath = join(dir, f);
-        const downPath = join(dir, `${m[1]}_${name}.down.sql`);
-        const upSql = readFileSync(upPath, "utf8");
-        out.push({
-            version,
-            name,
-            upPath,
-            downPath: existsSync(downPath) ? downPath : null,
-            upSql,
-            upHash: createHash("sha256").update(upSql).digest("hex"),
-            squash: parseSquashMetadata(upSql),
-        });
-    }
-    return out;
-}
-function parseSquashMetadata(sql) {
-    const line = sql.split(/\r?\n/).find((l) => l.startsWith(SQUASH_PREFIX));
-    if (!line)
-        return null;
-    const raw = line.slice(SQUASH_PREFIX.length).trim();
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (e) {
-        throw new Error(`sqlx-js.migrate: invalid squash metadata JSON: ${e.message}`);
-    }
-    if (!parsed || typeof parsed !== "object") {
-        throw new Error("sqlx-js.migrate: invalid squash metadata");
-    }
-    const obj = parsed;
-    if (obj.format !== 1 || !Array.isArray(obj.replaces) || obj.replaces.length === 0) {
-        throw new Error("sqlx-js.migrate: invalid squash metadata");
-    }
-    const replaces = [];
-    for (const r of obj.replaces) {
-        if (!r || typeof r !== "object")
-            throw new Error("sqlx-js.migrate: invalid squash replacement metadata");
-        const item = r;
-        if (typeof item.version !== "number" || !Number.isSafeInteger(item.version) || item.version <= 0) {
-            throw new Error("sqlx-js.migrate: invalid squash replacement version");
-        }
-        if (typeof item.name !== "string" || !SAFE_NAME_RE.test(item.name)) {
-            throw new Error("sqlx-js.migrate: invalid squash replacement name");
-        }
-        if (typeof item.upHash !== "string" || !/^[a-f0-9]{64}$/.test(item.upHash)) {
-            throw new Error("sqlx-js.migrate: invalid squash replacement hash");
-        }
-        replaces.push({ version: item.version, name: item.name, upHash: item.upHash });
-    }
-    return { format: 1, replaces };
-}
 function quoteIdent(ident) {
     return `"${ident.replace(/"/g, '""')}"`;
 }
@@ -91,104 +24,6 @@ function maintenanceDatabaseUrl(databaseUrl) {
 function generatedShadowDatabaseName() {
     return `sqlx_js_shadow_${process.pid}_${Date.now().toString(36)}_${randomBytes(4).toString("hex")}`;
 }
-async function findMigrationStore(c) {
-    const r = await c.simpleQuery(`
-    SELECT n.nspname, cls.relname
-    FROM pg_class cls
-    JOIN pg_namespace n ON n.oid = cls.relnamespace
-    WHERE cls.oid = to_regclass('${MIGRATIONS_TABLE}')
-  `);
-    const row = r.rows[0];
-    if (!row)
-        return null;
-    const schema = decodeText(row[0]);
-    const table = decodeText(row[1]);
-    if (!schema || !table) {
-        throw new Error(`sqlx-js.migrate: failed to resolve ${MIGRATIONS_TABLE} identifier`);
-    }
-    return { table: `${quoteIdent(schema)}.${quoteIdent(table)}` };
-}
-async function resolveMigrationStore(c) {
-    const store = await findMigrationStore(c);
-    if (!store) {
-        throw new Error(`sqlx-js.migrate: failed to resolve ${MIGRATIONS_TABLE} in current search_path`);
-    }
-    return store;
-}
-export async function ensureTable(c) {
-    const existing = await findMigrationStore(c);
-    if (existing)
-        return existing;
-    await c.simpleQuery(`
-    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-      version BIGINT PRIMARY KEY,
-      name TEXT NOT NULL,
-      up_hash TEXT NOT NULL,
-      applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
-    )
-  `);
-    return resolveMigrationStore(c);
-}
-export async function listApplied(c, store) {
-    const s = store ?? await resolveMigrationStore(c);
-    const r = await c.simpleQuery(`SELECT version, name, up_hash FROM ${s.table} ORDER BY version`);
-    const out = new Map();
-    for (const row of r.rows) {
-        out.set(Number(decodeText(row[0])), { name: decodeText(row[1]), hash: decodeText(row[2]) });
-    }
-    return out;
-}
-function appliedSquashSupersededVersions(all, applied, onEvent) {
-    const superseded = new Set();
-    const byVersion = new Map(all.map((m) => [m.version, m]));
-    const visitedSquashes = new Set();
-    const visitReplacements = (m) => {
-        if (!m.squash || visitedSquashes.has(m.version))
-            return true;
-        visitedSquashes.add(m.version);
-        for (const r of m.squash.replaces) {
-            superseded.add(r.version);
-            const current = byVersion.get(r.version);
-            if (!current?.squash || current.version >= m.version)
-                continue;
-            if (current.name !== r.name || current.upHash !== r.upHash) {
-                onEvent?.({ kind: "tampered", version: r.version, name: r.name, applied: r.upHash, current: current.upHash });
-                return false;
-            }
-            if (!visitReplacements(current))
-                return false;
-        }
-        return true;
-    };
-    for (const m of all) {
-        if (!m.squash)
-            continue;
-        const a = applied.get(m.version);
-        if (!a)
-            continue;
-        if (a.hash !== m.upHash) {
-            onEvent?.({ kind: "tampered", version: m.version, name: m.name, applied: a.hash, current: m.upHash });
-            return null;
-        }
-        if (!visitReplacements(m))
-            return null;
-    }
-    return superseded;
-}
-function squashCoveredVersions(all) {
-    const covered = new Set();
-    for (const m of all) {
-        if (!m.squash)
-            continue;
-        for (const r of m.squash.replaces) {
-            if (r.version >= m.version) {
-                throw new Error(`sqlx-js.migrate: squash replacement ${r.version}_${r.name} must be older than ${m.version}_${m.name}`);
-            }
-            covered.add(r.version);
-        }
-    }
-    return covered;
-}
 function migrationCheckIssue(code, message, details = {}) {
     return { severity: "error", code, message, ...details };
 }
@@ -489,6 +324,7 @@ async function validateLatestDownForWorkflow(databaseUrl, migrationsDir) {
     }
 }
 async function prepareWorkflowArtifacts(opts, databaseUrl) {
+    const { openSession, prepareOnce } = await import("./prepare.js");
     const prepareOpts = {
         root: opts.root,
         databaseUrl,
@@ -496,6 +332,7 @@ async function prepareWorkflowArtifacts(opts, databaseUrl) {
         dtsPath: opts.dtsPath,
         check: false,
         prune: opts.prune,
+        strictInference: opts.strictInference,
     };
     const session = await openSession(prepareOpts);
     try {
@@ -512,410 +349,18 @@ async function prepareWorkflowArtifacts(opts, databaseUrl) {
     }
 }
 async function prepareInTemporaryArtifacts(opts, databaseUrl) {
-    const tmp = mkdtempSync(join(tmpdir(), "sqlx-js-verify-"));
-    const cacheDir = join(tmp, "cache");
-    const dtsPath = join(tmp, "sqlx-js-env.d.ts");
-    const prepareOpts = {
+    const { verifyPrepareArtifacts } = await import("./prepare.js");
+    const verification = await verifyPrepareArtifacts({
         root: opts.root,
         databaseUrl,
-        cacheDir,
-        dtsPath,
+        cacheDir: opts.cacheDir,
+        dtsPath: opts.dtsPath,
         check: false,
+        verify: true,
         prune: true,
-    };
-    const session = await openSession(prepareOpts);
-    try {
-        const r = await prepareOnce(prepareOpts, session);
-        if (r.failures > 0) {
-            console.error(`\n${r.failures} query/queries failed to prepare`);
-            return false;
-        }
-        console.log(`shadow: prepared ${r.entries} unique query/queries`);
-        return true;
-    }
-    finally {
-        await session.client.end();
-        rmSync(tmp, { recursive: true, force: true });
-    }
-}
-function effectiveSquashReplacements(all) {
-    const covered = squashCoveredVersions(all);
-    return all
-        .filter((m) => !covered.has(m.version))
-        .map((m) => ({ version: m.version, name: m.name, upHash: m.upHash }));
-}
-function preflightSquashMigrations(all, applied, superseded, onEvent) {
-    const byVersion = new Map(all.map((m) => [m.version, m]));
-    for (const m of all) {
-        if (!m.squash)
-            continue;
-        let present = 0;
-        for (const r of m.squash.replaces) {
-            if (r.version >= m.version) {
-                onEvent?.({
-                    kind: "failed",
-                    version: m.version,
-                    name: m.name,
-                    error: `squash replacement ${r.version}_${r.name} must be older than ${m.version}_${m.name}`,
-                });
-                return "failed";
-            }
-            const current = byVersion.get(r.version);
-            if (current && !superseded.has(r.version) && (current.name !== r.name || current.upHash !== r.upHash)) {
-                onEvent?.({ kind: "tampered", version: r.version, name: r.name, applied: r.upHash, current: current.upHash });
-                return "tampered";
-            }
-            const a = applied.get(r.version);
-            if (!a)
-                continue;
-            present++;
-            if (a.hash !== r.upHash || a.name !== r.name) {
-                onEvent?.({ kind: "tampered", version: r.version, name: r.name, applied: a.hash, current: r.upHash });
-                return "tampered";
-            }
-        }
-        if (present > 0 && present !== m.squash.replaces.length) {
-            onEvent?.({
-                kind: "failed",
-                version: m.version,
-                name: m.name,
-                error: `squash migration replaces ${m.squash.replaces.length} migration(s), but only ${present} matching row(s) are applied`,
-            });
-            return "failed";
-        }
-    }
-    return "ok";
-}
-function planSquashAdoption(m, applied, onEvent) {
-    if (!m.squash)
-        return { kind: "none" };
-    let present = 0;
-    for (const r of m.squash.replaces) {
-        if (r.version >= m.version) {
-            onEvent?.({
-                kind: "failed",
-                version: m.version,
-                name: m.name,
-                error: `squash replacement ${r.version}_${r.name} must be older than ${m.version}_${m.name}`,
-            });
-            return { kind: "failed" };
-        }
-        const a = applied.get(r.version);
-        if (!a)
-            continue;
-        present++;
-        if (a.hash !== r.upHash || a.name !== r.name) {
-            onEvent?.({ kind: "tampered", version: r.version, name: r.name, applied: a.hash, current: r.upHash });
-            return { kind: "tampered" };
-        }
-    }
-    if (present === 0)
-        return { kind: "none" };
-    if (present !== m.squash.replaces.length) {
-        onEvent?.({
-            kind: "failed",
-            version: m.version,
-            name: m.name,
-            error: `squash migration replaces ${m.squash.replaces.length} migration(s), but only ${present} matching row(s) are applied`,
-        });
-        return { kind: "failed" };
-    }
-    return { kind: "adopt", replaced: m.squash.replaces.length };
-}
-function buildMigrationPlan(all, applied, onEvent) {
-    const plannedApplied = new Map(applied);
-    const superseded = appliedSquashSupersededVersions(all, plannedApplied, onEvent);
-    if (!superseded)
-        return { kind: "tampered" };
-    const preflight = preflightSquashMigrations(all, plannedApplied, superseded, onEvent);
-    if (preflight !== "ok")
-        return { kind: preflight };
-    const steps = [];
-    for (const m of all) {
-        if (superseded.has(m.version))
-            continue;
-        const a = plannedApplied.get(m.version);
-        if (a) {
-            if (a.hash !== m.upHash) {
-                onEvent?.({ kind: "tampered", version: m.version, name: m.name, applied: a.hash, current: m.upHash });
-                return { kind: "tampered" };
-            }
-            continue;
-        }
-        const adoption = planSquashAdoption(m, plannedApplied, onEvent);
-        if (adoption.kind === "adopt") {
-            steps.push({ kind: "adopt", migration: m, replaced: adoption.replaced });
-            for (const r of m.squash.replaces)
-                plannedApplied.delete(r.version);
-            plannedApplied.set(m.version, { name: m.name, hash: m.upHash });
-            continue;
-        }
-        if (adoption.kind === "tampered" || adoption.kind === "failed")
-            return { kind: adoption.kind };
-        steps.push({ kind: "apply", migration: m });
-        plannedApplied.set(m.version, { name: m.name, hash: m.upHash });
-    }
-    return { kind: "ok", steps };
-}
-function publicPlanItem(step) {
-    if (step.kind === "apply") {
-        return { kind: "apply", version: step.migration.version, name: step.migration.name };
-    }
-    return {
-        kind: "adopt",
-        version: step.migration.version,
-        name: step.migration.name,
-        replaced: step.replaced,
-    };
-}
-async function resetMigrationSession(c) {
-    await c.simpleQuery("RESET ALL");
-}
-async function executeSquashAdoption(c, store, m, applied, replaced, onEvent) {
-    if (!m.squash)
-        return "failed";
-    let committed = false;
-    await c.simpleQuery("BEGIN");
-    try {
-        for (const r of m.squash.replaces) {
-            await c.execParamsText(`DELETE FROM ${store.table} WHERE version = $1`, [String(r.version)]);
-        }
-        await c.execParamsText(`INSERT INTO ${store.table} (version, name, up_hash) VALUES ($1, $2, $3)`, [String(m.version), m.name, m.upHash]);
-        await c.simpleQuery("COMMIT");
-        committed = true;
-    }
-    catch (err) {
-        let rollbackErr;
-        if (!committed) {
-            try {
-                await c.simpleQuery("ROLLBACK");
-            }
-            catch (rb) {
-                rollbackErr = rb.message;
-            }
-        }
-        const message = rollbackErr
-            ? `${err.message} (rollback also failed: ${rollbackErr})`
-            : err.message;
-        onEvent?.({ kind: "failed", version: m.version, name: m.name, error: message });
-        return "failed";
-    }
-    try {
-        await resetMigrationSession(c);
-    }
-    catch (err) {
-        onEvent?.({ kind: "failed", version: m.version, name: m.name, error: `failed to reset migration session: ${err.message}` });
-        return "failed";
-    }
-    for (const r of m.squash.replaces)
-        applied.delete(r.version);
-    applied.set(m.version, { name: m.name, hash: m.upHash });
-    onEvent?.({ kind: "adopted", version: m.version, name: m.name, replaced });
-    return "done";
-}
-export async function planPending(c, migrationsDir, onEvent) {
-    const store = await findMigrationStore(c);
-    const applied = store ? await listApplied(c, store) : new Map();
-    const all = readMigrations(migrationsDir);
-    const counts = { pending: 0, adoptable: 0, tampered: 0, failed: 0 };
-    const plan = buildMigrationPlan(all, applied, onEvent);
-    if (plan.kind === "tampered") {
-        counts.tampered++;
-        return { ...counts, steps: [] };
-    }
-    if (plan.kind === "failed") {
-        counts.failed++;
-        return { ...counts, steps: [] };
-    }
-    const steps = plan.steps.map(publicPlanItem);
-    for (const step of steps) {
-        if (step.kind === "apply") {
-            counts.pending++;
-            onEvent?.({ kind: "pending", version: step.version, name: step.name });
-        }
-        else {
-            counts.adoptable++;
-            onEvent?.({ kind: "adoptable", version: step.version, name: step.name, replaced: step.replaced });
-        }
-    }
-    return { ...counts, steps };
-}
-export async function inspectMigrationPlan(c, migrationsDir) {
-    const diagnostics = [];
-    const result = await planPending(c, migrationsDir, (e) => {
-        if (e.kind === "tampered" || e.kind === "failed")
-            diagnostics.push(e);
+        strictInference: opts.strictInference,
     });
-    return {
-        ok: result.tampered === 0 && result.failed === 0,
-        ...result,
-        diagnostics,
-    };
-}
-export async function inspectMigrations(c, migrationsDir) {
-    const store = await findMigrationStore(c);
-    const applied = store ? await listApplied(c, store) : new Map();
-    const all = readMigrations(migrationsDir);
-    const validation = [];
-    const plan = buildMigrationPlan(all, applied, (e) => validation.push(e));
-    const planned = new Map();
-    if (plan.kind === "ok") {
-        for (const step of plan.steps)
-            planned.set(step.migration.version, step);
-    }
-    const validationByVersion = new Map(validation.map((e) => [e.version, e]));
-    const superseded = appliedSquashSupersededVersions(all, applied) ?? new Set();
-    const summary = {
-        applied: 0,
-        pending: 0,
-        adoptable: 0,
-        superseded: 0,
-        tampered: 0,
-        failed: 0,
-    };
-    const items = all.map((m) => {
-        const validationEvent = validationByVersion.get(m.version);
-        if (validationEvent?.kind === "tampered") {
-            summary.tampered++;
-            return {
-                version: m.version,
-                name: m.name,
-                status: "tampered",
-                detail: `hash mismatch: applied ${validationEvent.applied.slice(0, 16)} vs current ${validationEvent.current.slice(0, 16)}`,
-            };
-        }
-        if (validationEvent?.kind === "failed") {
-            summary.failed++;
-            return { version: m.version, name: m.name, status: "failed", detail: validationEvent.error };
-        }
-        if (superseded.has(m.version)) {
-            summary.superseded++;
-            return { version: m.version, name: m.name, status: "superseded" };
-        }
-        const a = applied.get(m.version);
-        if (a) {
-            if (a.hash !== m.upHash) {
-                summary.tampered++;
-                return {
-                    version: m.version,
-                    name: m.name,
-                    status: "tampered",
-                    detail: `hash mismatch: applied ${a.hash.slice(0, 16)} vs current ${m.upHash.slice(0, 16)}`,
-                };
-            }
-            summary.applied++;
-            return { version: m.version, name: m.name, status: "applied" };
-        }
-        const plannedStep = planned.get(m.version);
-        if (plannedStep?.kind === "adopt") {
-            summary.adoptable++;
-            return { version: m.version, name: m.name, status: "adoptable", detail: `${plannedStep.replaced} replaced` };
-        }
-        summary.pending++;
-        return { version: m.version, name: m.name, status: "pending" };
-    });
-    return { historyTable: store?.table ?? null, summary, items };
-}
-export async function applyPending(c, migrationsDir, onEvent) {
-    const store = await ensureTable(c);
-    const applied = await listApplied(c, store);
-    const all = readMigrations(migrationsDir);
-    const counts = { applied: 0, tampered: 0, failed: 0 };
-    const plan = buildMigrationPlan(all, applied, onEvent);
-    if (plan.kind === "tampered") {
-        counts.tampered++;
-        return counts;
-    }
-    if (plan.kind === "failed") {
-        counts.failed++;
-        return counts;
-    }
-    for (const step of plan.steps) {
-        const m = step.migration;
-        if (step.kind === "adopt") {
-            const adoption = await executeSquashAdoption(c, store, m, applied, step.replaced, onEvent);
-            if (adoption === "failed") {
-                counts.failed++;
-                return counts;
-            }
-            counts.applied++;
-            continue;
-        }
-        let committed = false;
-        await c.simpleQuery("BEGIN");
-        try {
-            await c.simpleQuery(m.upSql);
-            await c.execParamsText(`INSERT INTO ${store.table} (version, name, up_hash) VALUES ($1, $2, $3)`, [String(m.version), m.name, m.upHash]);
-            await c.simpleQuery("COMMIT");
-            committed = true;
-        }
-        catch (err) {
-            let rollbackErr;
-            if (!committed) {
-                try {
-                    await c.simpleQuery("ROLLBACK");
-                }
-                catch (rb) {
-                    rollbackErr = rb.message;
-                }
-            }
-            counts.failed++;
-            const message = rollbackErr
-                ? `${err.message} (rollback also failed: ${rollbackErr})`
-                : err.message;
-            onEvent?.({ kind: "failed", version: m.version, name: m.name, error: message });
-            return counts;
-        }
-        try {
-            await resetMigrationSession(c);
-        }
-        catch (err) {
-            counts.failed++;
-            onEvent?.({ kind: "failed", version: m.version, name: m.name, error: `failed to reset migration session: ${err.message}` });
-            return counts;
-        }
-        counts.applied++;
-        applied.set(m.version, { name: m.name, hash: m.upHash });
-        onEvent?.({ kind: "applied", version: m.version, name: m.name });
-    }
-    return counts;
-}
-function lockKeyToString(lockKey) {
-    if (typeof lockKey === "bigint")
-        return lockKey.toString();
-    if (!Number.isSafeInteger(lockKey)) {
-        throw new Error(`sqlx-js.migrate: lockKey must be a safe integer or bigint, got ${lockKey}`);
-    }
-    return BigInt(lockKey).toString();
-}
-export async function acquireMigrateLock(c, lockKey = DEFAULT_MIGRATE_LOCK_KEY, timeoutMs) {
-    if (timeoutMs !== undefined && !Number.isFinite(timeoutMs)) {
-        throw new Error(`sqlx-js.migrate: lockTimeoutMs must be a finite number, got ${timeoutMs}`);
-    }
-    const key = lockKeyToString(lockKey);
-    if (timeoutMs === undefined || timeoutMs <= 0) {
-        await c.simpleQuery(`SELECT pg_advisory_lock(${key})`);
-        return;
-    }
-    const start = Date.now();
-    let delay = 50;
-    while (true) {
-        const r = await c.simpleQuery(`SELECT pg_try_advisory_lock(${key})`);
-        const got = decodeText(r.rows[0]?.[0] ?? null) === "t";
-        if (got)
-            return;
-        const elapsed = Date.now() - start;
-        if (elapsed >= timeoutMs) {
-            throw new Error(`sqlx-js.migrate: failed to acquire advisory lock ${key} within ${timeoutMs}ms`);
-        }
-        const remaining = timeoutMs - elapsed;
-        await new Promise((resolve) => setTimeout(resolve, Math.min(delay, remaining)));
-        delay = Math.min(delay * 2, 2000);
-    }
-}
-export async function releaseMigrateLock(c, lockKey = DEFAULT_MIGRATE_LOCK_KEY) {
-    const key = lockKeyToString(lockKey);
-    await c.simpleQuery(`SELECT pg_advisory_unlock(${key})`);
+    return verification.ok;
 }
 function safeMigrationName(name) {
     const safe = name.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^[^a-zA-Z0-9]+/, "");

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

@@ -19,7 +19,13 @@ export type PgschemaInstallOptions = {
     baseUrl?: string;
     log?: (msg: string) => void;
 };
+export type PgschemaProbe = {
+    ok: boolean;
+    command?: string;
+    message: string;
+};
 export declare function resolvePgschemaAsset(platform?: NodeJS.Platform, arch?: NodeJS.Architecture): PgschemaAsset;
 export declare function managedPgschemaPath(root: string, asset?: PgschemaAsset): string;
+export declare function probePgschema(root: string, config: SqlxJsConfig): PgschemaProbe;
 export declare function runPgschemaInstall(opts: PgschemaInstallOptions): Promise<void>;
 export declare function runPgschemaCommand(opts: PgschemaCommandOptions): void;

package/dist/src/commands/pgschema.js

@@ -73,6 +73,36 @@ function commandName(root, config) {
         return managed;
     return "pgschema";
 }
+export function probePgschema(root, config) {
+    try {
+        const schema = pgschemaConfig(config);
+        const command = commandName(root, schema);
+        const child = spawnSync(command, ["--help"], {
+            encoding: "utf8",
+            env: process.env,
+            timeout: 5_000,
+        });
+        if (child.error) {
+            const code = child.error.code;
+            return {
+                ok: false,
+                command,
+                message: code === "ENOENT"
+                    ? installHint(command)
+                    : code === "ETIMEDOUT"
+                        ? `${command} --help timed out after 5000ms`
+                        : child.error.message,
+            };
+        }
+        if (child.status !== 0) {
+            return { ok: false, command, message: `${command} --help exited with ${child.status}` };
+        }
+        return { ok: true, command, message: `pgschema is available: ${command}` };
+    }
+    catch (e) {
+        return { ok: false, message: e.message };
+    }
+}
 function schemaFile(root, config) {
     return resolve(root, config.file ?? "schema.sql");
 }