neonctl 2.37.1 → 2.38.1

package/dist/psql/print/latex.js

@@ -1,379 +0,0 @@
-import { boolDisplayOf, renderCellValue } from "./units.js";
-/**
- * LaTeX printers — `latex` (tabular) and `latex-longtable` (longtable).
- *
- * Mirrors print.c `print_latex_text`, `print_latex_vertical`, and
- * `print_latex_longtable_text`. Expanded mode for both `latex` and
- * `latex-longtable` falls through to the vertical renderer
- * (`print_latex_vertical`) — that's how upstream dispatches.
- *
- * Border behavior (flat tabular, from print.c):
- *   - `topt.border` is clamped to 0..3.
- *   - tabular column spec gets ` | ` between columns when border > 0,
- *     and a leading/trailing `|` at border >= 2.
- *   - border == 2 emits `\hline` around header and at end of table.
- *   - border == 3 emits `\hline` after every row.
- *
- * Border behavior (expanded, from print.c):
- *   - `topt.border` is clamped to 0..2 (note: not 0..3).
- *   - tabular column spec is `cl`, `c|l`, or `|c|l|` for border 0/1/2.
- *   - border >= 1 emits `\hline` between records.
- *   - border == 2 wraps each "Record N" header in `\hline` lines.
- *
- * Numeric columns (per the OID heuristic) get the `r` alignment letter;
- * everything else gets `l`. That letter is passed straight through to
- * LaTeX's column spec.
- *
- * Escape: 14 LaTeX-special characters are rewritten. Embedded newlines
- * in a cell turn into `\\` (LaTeX line break) for `latex`. The
- * longtable variant uses the same escape but wraps cells in
- * `\raggedright{...}` and ends rows with `\tabularnewline`.
- */
-// INT2, INT4, INT8, FLOAT4, FLOAT8, NUMERIC, INTERVAL.
-const NUMERIC_OIDS = new Set([21, 23, 20, 700, 701, 1700, 1186]);
-export const latexPrinter = {
-    format: "latex",
-    printQuery(rs, opts, out) {
-        const topt = opts.topt;
-        if (topt.expanded === "on") {
-            return printLatexVertical(rs, opts, out);
-        }
-        return printLatexFlat(rs, opts, out);
-    },
-};
-const printLatexFlat = (rs, opts, out) => {
-    const topt = opts.topt;
-    const tuplesOnly = topt.tuplesOnly;
-    const startTable = topt.startTable;
-    const stopTable = topt.stopTable;
-    const border = clampBorder(topt.border, 3);
-    const nullPrint = opts.nullPrint !== "" ? opts.nullPrint : topt.nullPrint;
-    const title = opts.title ?? topt.title;
-    const footers = opts.footers ?? topt.footers;
-    const headers = rs.fields.map((f) => f.name);
-    const ncols = rs.fields.length;
-    const aligns = rs.fields.map((f) => NUMERIC_OIDS.has(f.dataTypeID) ? "r" : "l");
-    const boolDisplay = boolDisplayOf(topt);
-    const cells = rs.rows.map((row) => row.map((cell, i) => renderCell(cell, nullPrint, topt.numericLocale, rs.fields[i]?.dataTypeID, boolDisplay)));
-    let buf = "";
-    if (startTable) {
-        if (!tuplesOnly && title) {
-            buf += "\\begin{center}\n";
-            buf += escapeLatex(title);
-            buf += "\n\\end{center}\n\n";
-        }
-        buf += "\\begin{tabular}{";
-        if (border >= 2)
-            buf += "| ";
-        aligns.forEach((a, idx) => {
-            buf += a;
-            if (border !== 0 && idx < ncols - 1)
-                buf += " | ";
-        });
-        if (border >= 2)
-            buf += " |";
-        buf += "}\n";
-        if (!tuplesOnly && border >= 2)
-            buf += "\\hline\n";
-        if (!tuplesOnly) {
-            headers.forEach((h, idx) => {
-                if (idx !== 0)
-                    buf += " & ";
-                buf += "\\textit{" + escapeLatex(h) + "}";
-            });
-            buf += " \\\\\n";
-            buf += "\\hline\n";
-        }
-    }
-    cells.forEach((row) => {
-        row.forEach((value, idx) => {
-            buf += escapeLatex(value);
-            if (idx === ncols - 1) {
-                buf += " \\\\\n";
-                if (border === 3)
-                    buf += "\\hline\n";
-            }
-            else {
-                buf += " & ";
-            }
-        });
-    });
-    if (stopTable) {
-        if (border === 2)
-            buf += "\\hline\n";
-        buf += "\\end{tabular}\n\n\\noindent ";
-        if (!tuplesOnly) {
-            const effective = effectiveFooters(rs, topt, footers);
-            for (const f of effective) {
-                buf += escapeLatex(f) + " \\\\\n";
-            }
-        }
-        buf += "\n";
-    }
-    out.write(buf);
-    return Promise.resolve();
-};
-const printLatexVertical = (rs, opts, out) => {
-    const topt = opts.topt;
-    const tuplesOnly = topt.tuplesOnly;
-    const startTable = topt.startTable;
-    const stopTable = topt.stopTable;
-    const border = clampBorder(topt.border, 2);
-    const nullPrint = opts.nullPrint !== "" ? opts.nullPrint : topt.nullPrint;
-    const title = opts.title ?? topt.title;
-    const footers = opts.footers ?? topt.footers;
-    const headers = rs.fields.map((f) => f.name);
-    const boolDisplay = boolDisplayOf(topt);
-    const cells = rs.rows.map((row) => row.map((cell, i) => renderCell(cell, nullPrint, topt.numericLocale, rs.fields[i]?.dataTypeID, boolDisplay)));
-    let buf = "";
-    if (startTable) {
-        if (!tuplesOnly && title) {
-            buf += "\\begin{center}\n";
-            buf += escapeLatex(title);
-            buf += "\n\\end{center}\n\n";
-        }
-        buf += "\\begin{tabular}{";
-        if (border === 0)
-            buf += "cl";
-        else if (border === 1)
-            buf += "c|l";
-        else
-            buf += "|c|l|";
-        buf += "}\n";
-    }
-    let record = topt.prior + 1;
-    cells.forEach((row) => {
-        if (!tuplesOnly) {
-            if (border === 2) {
-                buf += "\\hline\n";
-                buf += `\\multicolumn{2}{|c|}{\\textit{Record ${String(record)}}} \\\\\n`;
-            }
-            else {
-                buf += `\\multicolumn{2}{c}{\\textit{Record ${String(record)}}} \\\\\n`;
-            }
-            record += 1;
-        }
-        if (border >= 1)
-            buf += "\\hline\n";
-        row.forEach((value, idx) => {
-            buf += escapeLatex(headers[idx]);
-            buf += " & ";
-            buf += escapeLatex(value);
-            buf += " \\\\\n";
-        });
-    });
-    if (stopTable) {
-        if (border === 2)
-            buf += "\\hline\n";
-        buf += "\\end{tabular}\n\n\\noindent ";
-        // Expanded mode does NOT include the default "(N rows)" footer;
-        // only user-supplied footers (matches print_latex_vertical).
-        if (!tuplesOnly && footers && footers.length > 0) {
-            for (const f of footers) {
-                buf += escapeLatex(f) + " \\\\\n";
-            }
-        }
-        buf += "\n";
-    }
-    out.write(buf);
-    return Promise.resolve();
-};
-export const latexLongtablePrinter = {
-    format: "latex-longtable",
-    printQuery(rs, opts, out) {
-        // Upstream dispatch sends both `latex` and `latex-longtable` to
-        // `print_latex_vertical` when expanded is on (cf. print.c).
-        if (opts.topt.expanded === "on") {
-            return printLatexVertical(rs, opts, out);
-        }
-        const topt = opts.topt;
-        const tuplesOnly = topt.tuplesOnly;
-        const startTable = topt.startTable;
-        const stopTable = topt.stopTable;
-        const border = clampBorder(topt.border, 3);
-        const nullPrint = opts.nullPrint !== "" ? opts.nullPrint : topt.nullPrint;
-        const title = opts.title ?? topt.title;
-        const headers = rs.fields.map((f) => f.name);
-        const ncols = rs.fields.length;
-        const aligns = rs.fields.map((f) => NUMERIC_OIDS.has(f.dataTypeID) ? "r" : "l");
-        const boolDisplay = boolDisplayOf(topt);
-        const cells = rs.rows.map((row) => row.map((cell, i) => renderCell(cell, nullPrint, topt.numericLocale, rs.fields[i]?.dataTypeID, boolDisplay)));
-        // `topt.tableAttr` for longtable encodes per-column widths in a
-        // whitespace-separated list, consumed left-to-right with a fall
-        // back to the previous value once exhausted.
-        const widths = (topt.tableAttr ?? "")
-            .split(/[\s]+/)
-            .filter((w) => w !== "");
-        let widthCursor = 0;
-        let lastWidth = null;
-        let buf = "";
-        if (startTable) {
-            buf += "\\begin{longtable}{";
-            if (border >= 2)
-                buf += "| ";
-            aligns.forEach((a, idx) => {
-                if (a === "l" && widths.length > 0) {
-                    let w = null;
-                    if (widthCursor < widths.length) {
-                        w = widths[widthCursor];
-                        widthCursor += 1;
-                        lastWidth = w;
-                    }
-                    else if (lastWidth !== null) {
-                        w = lastWidth;
-                    }
-                    if (w !== null) {
-                        buf += `p{${w}\\textwidth}`;
-                    }
-                    else {
-                        buf += "l";
-                    }
-                }
-                else {
-                    buf += a;
-                }
-                if (border !== 0 && idx < ncols - 1)
-                    buf += " | ";
-            });
-            if (border >= 2)
-                buf += " |";
-            buf += "}\n";
-            if (!tuplesOnly) {
-                // firsthead
-                if (border >= 2)
-                    buf += "\\toprule\n";
-                headers.forEach((h, idx) => {
-                    if (idx !== 0)
-                        buf += " & ";
-                    buf += "\\small\\textbf{\\textit{" + escapeLatex(h) + "}}";
-                });
-                buf += " \\\\\n";
-                buf += "\\midrule\n\\endfirsthead\n";
-                // continuation heads
-                if (border >= 2)
-                    buf += "\\toprule\n";
-                headers.forEach((h, idx) => {
-                    if (idx !== 0)
-                        buf += " & ";
-                    buf += "\\small\\textbf{\\textit{" + escapeLatex(h) + "}}";
-                });
-                buf += " \\\\\n";
-                if (border !== 3)
-                    buf += "\\midrule\n";
-                buf += "\\endhead\n";
-                if (title) {
-                    if (border === 2)
-                        buf += "\\bottomrule\n";
-                    buf +=
-                        "\\caption[" +
-                            escapeLatex(title) +
-                            " (Continued)]{" +
-                            escapeLatex(title) +
-                            "}\n\\endfoot\n";
-                    if (border === 2)
-                        buf += "\\bottomrule\n";
-                    buf +=
-                        "\\caption[" +
-                            escapeLatex(title) +
-                            "]{" +
-                            escapeLatex(title) +
-                            "}\n\\endlastfoot\n";
-                }
-                else if (border >= 2) {
-                    buf += "\\bottomrule\n\\endfoot\n";
-                    buf += "\\bottomrule\n\\endlastfoot\n";
-                }
-            }
-        }
-        // Cells. Upstream interleaves `\n&\n` between in-row cells (and
-        // emits `\tabularnewline` to end a row), wrapping each value in
-        // `\raggedright{...}`.
-        let cellIdx = 0;
-        cells.forEach((row) => {
-            row.forEach((value) => {
-                if (cellIdx !== 0 && cellIdx % ncols !== 0)
-                    buf += "\n&\n";
-                buf += "\\raggedright{" + escapeLatex(value) + "}";
-                if ((cellIdx + 1) % ncols === 0) {
-                    buf += " \\tabularnewline\n";
-                    if (border === 3)
-                        buf += " \\hline\n";
-                }
-                cellIdx += 1;
-            });
-        });
-        if (stopTable)
-            buf += "\\end{longtable}\n";
-        out.write(buf);
-        return Promise.resolve();
-    },
-};
-const clampBorder = (b, max) => {
-    if (b > max)
-        return max;
-    if (b < 0)
-        return 0;
-    return b;
-};
-const effectiveFooters = (rs, topt, footers) => {
-    if (footers && footers.length > 0)
-        return footers;
-    if (topt.defaultFooter) {
-        const n = rs.rows.length;
-        return [`(${String(n)} ${n === 1 ? "row" : "rows"})`];
-    }
-    return [];
-};
-const escapeLatex = (input) => {
-    let out = "";
-    for (const ch of input) {
-        switch (ch) {
-            case "#":
-                out += "\\#";
-                break;
-            case "$":
-                out += "\\$";
-                break;
-            case "%":
-                out += "\\%";
-                break;
-            case "&":
-                out += "\\&";
-                break;
-            case "<":
-                out += "\\textless{}";
-                break;
-            case ">":
-                out += "\\textgreater{}";
-                break;
-            case "\\":
-                out += "\\textbackslash{}";
-                break;
-            case "^":
-                out += "\\^{}";
-                break;
-            case "_":
-                out += "\\_";
-                break;
-            case "{":
-                out += "\\{";
-                break;
-            case "|":
-                out += "\\textbar{}";
-                break;
-            case "}":
-                out += "\\}";
-                break;
-            case "~":
-                out += "\\~{}";
-                break;
-            case "\n":
-                out += "\\\\";
-                break;
-            default:
-                out += ch;
-        }
-    }
-    return out;
-};
-const renderCell = (cell, nullPrint, numericLocale, dataTypeID, boolDisplay) => renderCellValue(cell, nullPrint, numericLocale, dataTypeID, boolDisplay);

package/dist/psql/print/pager.js

@@ -1,267 +0,0 @@
-import { accessSync, constants as fsConstants } from "node:fs";
-import { spawn } from "child_process";
-import { basename, delimiter, isAbsolute, join } from "path";
-/**
- * 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)));
-};
-/**
- * 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 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);
-};
-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;
-};
-/** 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;
-};
-/**
- * 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,
-    });
-};
-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 };
-};
-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 noOpHandle = (out) => ({
-    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;
-        },
-    };
-};