neon 2.47.0 → 3.1.0

package/dist/psql/print/pager.js

@@ -1,267 +1,196 @@
-import { accessSync, constants as fsConstants } from "node:fs";
+import { accessSync, constants } from "node:fs";
 import { spawn } from "child_process";
 import { basename, delimiter, isAbsolute, join } from "path";
+//#region src/psql/print/pager.ts
 /**
- * Can `command` be spawned with `shell:false`? A bare name is searched on
- * `$PATH`; a path is checked directly. Used to avoid `spawn(missingBinary,
- * { shell:false })`, which does NOT throw synchronously (our try/catch never
- * fires) but emits an async ENOENT — leaving writes to the dead child's stdin
- * to vanish into a blank terminal (review item #19).
- */
+* Can `command` be spawned with `shell:false`? A bare name is searched on
+* `$PATH`; a path is checked directly. Used to avoid `spawn(missingBinary,
+* { shell:false })`, which does NOT throw synchronously (our try/catch never
+* fires) but emits an async ENOENT — leaving writes to the dead child's stdin
+* to vanish into a blank terminal (review item #19).
+*/
 const pagerCommandResolvable = (command) => {
-    const ok = (p) => {
-        try {
-            accessSync(p, fsConstants.X_OK);
-            return true;
-        }
-        catch {
-            // On Windows X_OK is not meaningful and a bare name omits `.exe`; fall
-            // back to a plain existence probe with common executable extensions.
-            if (process.platform === "win32") {
-                for (const ext of ["", ".exe", ".cmd", ".bat"]) {
-                    try {
-                        accessSync(p + ext, fsConstants.F_OK);
-                        return true;
-                    }
-                    catch {
-                        /* keep trying */
-                    }
-                }
-            }
-            return false;
-        }
-    };
-    if (command.includes("/") ||
-        command.includes("\\") ||
-        isAbsolute(command)) {
-        return ok(command);
-    }
-    return (process.env.PATH ?? "")
-        .split(delimiter)
-        .filter((d) => d.length > 0)
-        .some((dir) => ok(join(dir, command)));
+	const ok = (p) => {
+		try {
+			accessSync(p, constants.X_OK);
+			return true;
+		} catch {
+			if (process.platform === "win32") for (const ext of [
+				"",
+				".exe",
+				".cmd",
+				".bat"
+			]) try {
+				accessSync(p + ext, constants.F_OK);
+				return true;
+			} catch {}
+			return false;
+		}
+	};
+	if (command.includes("/") || command.includes("\\") || isAbsolute(command)) return ok(command);
+	return (process.env.PATH ?? "").split(delimiter).filter((d) => d.length > 0).some((dir) => ok(join(dir, command)));
 };
 /**
- * Resolve the pager command string. Mirrors upstream:
- *   PSQL_PAGER → PAGER → DEFAULT_PAGER (`less` on POSIX, none on Windows).
- *
- * Empty / whitespace-only env values FALL THROUGH to the next candidate. This
- * deliberately diverges from strict upstream (where `PSQL_PAGER=''` would
- * disable the pager outright) because in Node a spawned child cannot easily
- * "unset" an inherited env var — tests have to override it with the empty
- * string. Treating empty values as "unset" matches the conformance spec
- * (`tests/psql-conformance/tap/030_pager.spec.ts`) and lets `PSQL_PAGER=''`
- * fall through to PAGER, which is the user-friendly interpretation.
- *
- * Users who want to disable the pager unconditionally should set
- * `\pset pager off` (preferred) or unset both env vars before launch.
- */
+* Resolve the pager command string. Mirrors upstream:
+*   PSQL_PAGER → PAGER → DEFAULT_PAGER (`less` on POSIX, none on Windows).
+*
+* Empty / whitespace-only env values FALL THROUGH to the next candidate. This
+* deliberately diverges from strict upstream (where `PSQL_PAGER=''` would
+* disable the pager outright) because in Node a spawned child cannot easily
+* "unset" an inherited env var — tests have to override it with the empty
+* string. Treating empty values as "unset" matches the conformance spec
+* (`tests/psql-conformance/tap/030_pager.spec.ts`) and lets `PSQL_PAGER=''`
+* fall through to PAGER, which is the user-friendly interpretation.
+*
+* Users who want to disable the pager unconditionally should set
+* `\pset pager off` (preferred) or unset both env vars before launch.
+*/
 const resolvePagerCmd = (opts) => {
-    const env = opts.env ?? process.env;
-    const candidates = [
-        opts.pagerCmd,
-        env.PSQL_PAGER,
-        env.PAGER,
-    ];
-    for (const c of candidates) {
-        if (c === undefined)
-            continue;
-        // Empty or whitespace-only → treat as "not set" and try the next slot.
-        if (/^\s*$/.test(c))
-            continue;
-        return c;
-    }
-    // DEFAULT_PAGER: `less` on POSIX; nothing on Windows.
-    if (process.platform === "win32")
-        return "";
-    return "less";
+	const env = opts.env ?? process.env;
+	const candidates = [
+		opts.pagerCmd,
+		env.PSQL_PAGER,
+		env.PAGER
+	];
+	for (const c of candidates) {
+		if (c === void 0) continue;
+		if (/^\s*$/.test(c)) continue;
+		return c;
+	}
+	if (process.platform === "win32") return "";
+	return "less";
 };
 const getIsTty = (opts) => {
-    if (opts.isTty !== undefined)
-        return opts.isTty;
-    const stream = opts.stdout ?? process.stdout;
-    // Some test streams won't have isTTY.
-    const tty = stream.isTTY;
-    return Boolean(tty);
+	if (opts.isTty !== void 0) return opts.isTty;
+	const tty = (opts.stdout ?? process.stdout).isTTY;
+	return Boolean(tty);
 };
 const getTerminalHeight = (opts) => {
-    if (opts.terminalHeight !== undefined)
-        return opts.terminalHeight;
-    const stream = opts.stdout ?? process.stdout;
-    const rows = stream.rows;
-    // If we can't tell, fall back to 24 (classic VT100 default).
-    return typeof rows === "number" && rows > 0 ? rows : 24;
+	if (opts.terminalHeight !== void 0) return opts.terminalHeight;
+	const rows = (opts.stdout ?? process.stdout).rows;
+	return typeof rows === "number" && rows > 0 ? rows : 24;
 };
 /** Standalone helper to determine whether a pager is needed at all. */
-export const isPagerNeeded = (opts) => {
-    if (opts.pager === "off")
-        return false;
-    const cmd = resolvePagerCmd(opts);
-    if (cmd === "")
-        return false;
-    if (opts.pager === "always")
-        return true;
-    // pager === 'on'
-    if (!getIsTty(opts))
-        return false;
-    if (opts.lines === undefined)
-        return false;
-    const threshold = Math.max(opts.pagerMinLines, getTerminalHeight(opts));
-    return opts.lines >= threshold;
+const isPagerNeeded = (opts) => {
+	if (opts.pager === "off") return false;
+	if (resolvePagerCmd(opts) === "") return false;
+	if (opts.pager === "always") return true;
+	if (!getIsTty(opts)) return false;
+	if (opts.lines === void 0) return false;
+	const threshold = Math.max(opts.pagerMinLines, getTerminalHeight(opts));
+	return opts.lines >= threshold;
 };
 /**
- * Decide whether a result of `rowCount` rows by `colCount` columns should be
- * routed through the pager when written to `output`.
- *
- * NOTE on `pager === 'always'`: the TTY check is INTENTIONALLY skipped in
- * this case. Upstream's `\pset pager always` is a user-explicit "force the
- * pager on" override; honouring it on a pipe matches the integration test
- * harness contract (see `tests/psql-conformance/tap/030_pager.spec.ts`) where
- * the child process has no controlling TTY but the spec still requires the
- * configured PAGER to be invoked. For `pager === 'on'` (auto mode) we keep
- * the TTY guard so non-interactive runs don't spuriously spawn `less`.
- */
-export const shouldPage = (opts) => {
-    if (opts.pager === "off")
-        return false;
-    if (opts.redirectedOutput)
-        return false;
-    // Rough heuristic for "lines" — header (3) + rows + footer (1). Matches
-    // upstream `IsPagerNeeded` which counts rendered table lines.
-    const HEADER_LINES = 3;
-    const FOOTER_LINES = 1;
-    const estimatedLines = HEADER_LINES + Math.max(0, opts.rowCount) + FOOTER_LINES;
-    // TTY check: explicit override wins, else inspect the stream's own isTTY.
-    const isTty = opts.isTty !== undefined
-        ? opts.isTty
-        : Boolean(opts.output.isTTY);
-    // `pager === 'always'` bypasses the TTY guard — see the docstring above.
-    // The remaining gates (resolved cmd, redirected output, off) are enforced
-    // inside `isPagerNeeded`.
-    if (opts.pager !== "always" && !isTty)
-        return false;
-    return isPagerNeeded({
-        pager: opts.pager,
-        pagerMinLines: opts.pagerMinLines,
-        pagerCmd: opts.pagerCmd,
-        env: opts.env,
-        stdout: opts.output,
-        isTty,
-        terminalHeight: opts.terminalHeight,
-        lines: estimatedLines,
-    });
+* Decide whether a result of `rowCount` rows by `colCount` columns should be
+* routed through the pager when written to `output`.
+*
+* NOTE on `pager === 'always'`: the TTY check is INTENTIONALLY skipped in
+* this case. Upstream's `\pset pager always` is a user-explicit "force the
+* pager on" override; honouring it on a pipe matches the integration test
+* harness contract (see `tests/psql-conformance/tap/030_pager.spec.ts`) where
+* the child process has no controlling TTY but the spec still requires the
+* configured PAGER to be invoked. For `pager === 'on'` (auto mode) we keep
+* the TTY guard so non-interactive runs don't spuriously spawn `less`.
+*/
+const shouldPage = (opts) => {
+	if (opts.pager === "off") return false;
+	if (opts.redirectedOutput) return false;
+	const estimatedLines = 3 + Math.max(0, opts.rowCount) + 1;
+	const isTty = opts.isTty !== void 0 ? opts.isTty : Boolean(opts.output.isTTY);
+	if (opts.pager !== "always" && !isTty) return false;
+	return isPagerNeeded({
+		pager: opts.pager,
+		pagerMinLines: opts.pagerMinLines,
+		pagerCmd: opts.pagerCmd,
+		env: opts.env,
+		stdout: opts.output,
+		isTty,
+		terminalHeight: opts.terminalHeight,
+		lines: estimatedLines
+	});
 };
 const SHELL_META = /[\s|;><]/;
 const parsePagerCmd = (cmd) => {
-    // Match upstream behavior: when the value looks shell-y, hand it off to
-    // /bin/sh -c. Otherwise treat it as a direct argv[0].
-    if (SHELL_META.test(cmd)) {
-        return { command: cmd, args: [], shell: true };
-    }
-    return { command: cmd, args: [], shell: false };
+	if (SHELL_META.test(cmd)) return {
+		command: cmd,
+		args: [],
+		shell: true
+	};
+	return {
+		command: cmd,
+		args: [],
+		shell: false
+	};
 };
 const buildPagerEnv = (cmd, baseEnv) => {
-    const env = { ...baseEnv };
-    // psql sets LESS=FRX by default; mirror it when the resolved pager is
-    // `less` and the caller hasn't already set LESS.
-    if (env.LESS === undefined) {
-        // Pull out the first whitespace-separated token to detect `less` even
-        // when args follow (e.g. "less -S").
-        const firstToken = cmd.trim().split(/\s+/, 1)[0] ?? "";
-        const program = basename(firstToken);
-        if (program === "less") {
-            env.LESS = "FRX";
-        }
-    }
-    return env;
+	const env = { ...baseEnv };
+	if (env.LESS === void 0) {
+		const firstToken = cmd.trim().split(/\s+/, 1)[0] ?? "";
+		if (basename(firstToken) === "less") env.LESS = "FRX";
+	}
+	return env;
 };
 const noOpHandle = (out) => ({
-    out,
-    spawned: false,
-    close: () => Promise.resolve(0),
+	out,
+	spawned: false,
+	close: () => Promise.resolve(0)
 });
 /**
- * Returns a PagerHandle. Caller writes data to `out`, then calls `close()`.
- * If no pager spawned (pager='off', not a TTY, or fewer lines than threshold),
- * `out` is `stdout`.
- */
-export const openPager = (opts) => {
-    const stdout = opts.stdout ?? process.stdout;
-    if (!isPagerNeeded(opts)) {
-        return noOpHandle(stdout);
-    }
-    const cmd = resolvePagerCmd(opts);
-    // isPagerNeeded already verified cmd is non-empty, but guard for safety.
-    if (cmd === "") {
-        return noOpHandle(stdout);
-    }
-    const { command, shell } = parsePagerCmd(cmd);
-    // A missing pager binary with shell:false emits an async ENOENT that the
-    // try/catch below cannot catch, and the result would be silently-discarded
-    // output. Pre-check and fall back to stdout instead (review item #19).
-    // shell:true goes through `sh -c`, which always exists.
-    if (!shell && !pagerCommandResolvable(command)) {
-        return noOpHandle(stdout);
-    }
-    const baseEnv = opts.env ?? process.env;
-    const childEnv = buildPagerEnv(cmd, baseEnv);
-    let child;
-    try {
-        child = spawn(command, [], {
-            stdio: ["pipe", "inherit", "inherit"],
-            shell,
-            env: childEnv,
-        });
-    }
-    catch {
-        // If the pager fails to spawn, fall back to stdout (matches upstream:
-        // `if (pagerpipe) return pagerpipe; restore_sigpipe_trap(); ... return stdout`).
-        return noOpHandle(stdout);
-    }
-    const stdin = child.stdin;
-    if (stdin === null) {
-        // Should not happen given stdio: ['pipe', ...], but be defensive.
-        return noOpHandle(stdout);
-    }
-    // Swallow EPIPE: the user can quit the pager early, after which any
-    // pending writes will fail with EPIPE. Upstream relies on SIGPIPE being
-    // ignored to short-circuit the write loop; we just drop the error.
-    stdin.on("error", (err) => {
-        if (err.code !== "EPIPE") {
-            // Re-throw anything unexpected.
-            throw err;
-        }
-    });
-    const exitPromise = new Promise((resolve) => {
-        const settle = (code) => {
-            resolve(code ?? 0);
-        };
-        child.once("exit", (code) => {
-            settle(code);
-        });
-        child.once("error", () => {
-            // If the child errored (e.g. ENOENT), surface a non-zero exit code
-            // but don't throw — the caller's writes will have hit EPIPE which
-            // we already swallow.
-            settle(127);
-        });
-    });
-    return {
-        out: stdin,
-        spawned: true,
-        close: () => {
-            // End stdin then wait for the pager to drain & exit.
-            if (!stdin.writableEnded) {
-                try {
-                    stdin.end();
-                }
-                catch (err) {
-                    const e = err;
-                    if (e.code !== "EPIPE")
-                        throw err;
-                }
-            }
-            return exitPromise;
-        },
-    };
+* Returns a PagerHandle. Caller writes data to `out`, then calls `close()`.
+* If no pager spawned (pager='off', not a TTY, or fewer lines than threshold),
+* `out` is `stdout`.
+*/
+const openPager = (opts) => {
+	const stdout = opts.stdout ?? process.stdout;
+	if (!isPagerNeeded(opts)) return noOpHandle(stdout);
+	const cmd = resolvePagerCmd(opts);
+	if (cmd === "") return noOpHandle(stdout);
+	const { command, shell } = parsePagerCmd(cmd);
+	if (!shell && !pagerCommandResolvable(command)) return noOpHandle(stdout);
+	const baseEnv = opts.env ?? process.env;
+	const childEnv = buildPagerEnv(cmd, baseEnv);
+	let child;
+	try {
+		child = spawn(command, [], {
+			stdio: [
+				"pipe",
+				"inherit",
+				"inherit"
+			],
+			shell,
+			env: childEnv
+		});
+	} catch {
+		return noOpHandle(stdout);
+	}
+	const stdin = child.stdin;
+	if (stdin === null) return noOpHandle(stdout);
+	stdin.on("error", (err) => {
+		if (err.code !== "EPIPE") throw err;
+	});
+	const exitPromise = new Promise((resolve) => {
+		const settle = (code) => {
+			resolve(code ?? 0);
+		};
+		child.once("exit", (code) => {
+			settle(code);
+		});
+		child.once("error", () => {
+			settle(127);
+		});
+	});
+	return {
+		out: stdin,
+		spawned: true,
+		close: () => {
+			if (!stdin.writableEnded) try {
+				stdin.end();
+			} catch (err) {
+				if (err.code !== "EPIPE") throw err;
+			}
+			return exitPromise;
+		}
+	};
 };
+//#endregion
+export { isPagerNeeded, openPager, shouldPage };