neonctl 2.22.0 → 2.23.0

package/psql/print/html.js

@@ -0,0 +1,258 @@
+import { formatNumericLocale } from './units.js';
+/**
+ * HTML printer.
+ *
+ * Mirrors print.c `print_html_text` and `print_html_vertical`.
+ *
+ * Output shape (flat):
+ *   <table border="1">
+ *     <caption>title</caption>
+ *     <tr>
+ *       <th align="center">col</th>
+ *       ...
+ *     </tr>
+ *     <tr valign="top">
+ *       <td align="left">val</td>
+ *       ...
+ *     </tr>
+ *     ...
+ *   </table>
+ *   <p>(N rows)<br />
+ *   footer<br />
+ *   </p>
+ *
+ * Output shape (expanded, `\pset expanded on`):
+ *   <table border="1">
+ *     <caption>title</caption>
+ *
+ *     <tr><td colspan="2" align="center">Record 1</td></tr>
+ *     <tr valign="top">
+ *       <th>col</th>
+ *       <td align="left">val</td>
+ *     </tr>
+ *     ...
+ *   </table>
+ *   <p>user footer<br />
+ *   </p>
+ *
+ * - `topt.tableAttr` is appended to the opening `<table>` tag.
+ * - `topt.border` becomes the `border="..."` value.
+ * - `topt.startTable` / `stopTable` gate the prologue/epilogue, allowing
+ *   chunked streaming. For this WP both default to true, so the full
+ *   document is emitted in one call.
+ * - Right-align numeric columns based on the PG type-OID heuristic
+ *   (`NUMERIC_OIDS`), matching how `print_aligned_text` derives the
+ *   `aligns` array upstream.
+ * - Cells that are whitespace-only render `&nbsp; ` so the cell still
+ *   takes layout space (verbatim upstream behavior).
+ * - Expanded mode renders a `<tr><td colspan="2" align="center">Record
+ *   N</td></tr>` separator before each row (or `&nbsp;` placeholder
+ *   when `tuplesOnly`); it never emits the default `(N rows)` footer.
+ */
+// INT2, INT4, INT8, FLOAT4, FLOAT8, NUMERIC, INTERVAL.
+const NUMERIC_OIDS = new Set([21, 23, 20, 700, 701, 1700, 1186]);
+export const htmlPrinter = {
+    format: 'html',
+    printQuery(rs, opts, out) {
+        const topt = opts.topt;
+        if (topt.expanded === 'on') {
+            return printExpanded(rs, opts, out);
+        }
+        return printFlat(rs, opts, out);
+    },
+};
+const printFlat = (rs, opts, out) => {
+    const topt = opts.topt;
+    const tuplesOnly = topt.tuplesOnly;
+    const startTable = topt.startTable;
+    const stopTable = topt.stopTable;
+    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 aligns = rs.fields.map((f) => NUMERIC_OIDS.has(f.dataTypeID) ? 'right' : 'left');
+    const cells = rs.rows.map((row) => row.map((cell) => renderCell(cell, nullPrint, topt.numericLocale)));
+    let buf = '';
+    if (startTable) {
+        buf += `<table border="${String(topt.border)}"`;
+        if (topt.tableAttr)
+            buf += ` ${topt.tableAttr}`;
+        buf += '>\n';
+        if (!tuplesOnly && title) {
+            buf += '  <caption>' + escapeHtml(title) + '</caption>\n';
+        }
+        if (!tuplesOnly) {
+            buf += '  <tr>\n';
+            for (const h of headers) {
+                buf += '    <th align="center">' + escapeHtml(h) + '</th>\n';
+            }
+            buf += '  </tr>\n';
+        }
+    }
+    for (const row of cells) {
+        buf += '  <tr valign="top">\n';
+        row.forEach((value, idx) => {
+            buf += `    <td align="${aligns[idx]}">`;
+            if (isWhitespaceOnly(value)) {
+                buf += '&nbsp; ';
+            }
+            else {
+                buf += escapeHtml(value);
+            }
+            buf += '</td>\n';
+        });
+        buf += '  </tr>\n';
+    }
+    if (stopTable) {
+        buf += '</table>\n';
+        if (!tuplesOnly) {
+            const effective = effectiveFooters(rs, topt, footers);
+            if (effective.length > 0) {
+                buf += '<p>';
+                for (const f of effective) {
+                    buf += escapeHtml(f) + '<br />\n';
+                }
+                buf += '</p>';
+            }
+        }
+        // Upstream `print_html_text` finishes with an unconditional
+        // `fputc('\n', fout)` AFTER the (optional) `<p>...</p>` block. The
+        // trailing newline appears regardless of footers / tuplesOnly.
+        buf += '\n';
+    }
+    out.write(buf);
+    return Promise.resolve();
+};
+const printExpanded = (rs, opts, out) => {
+    const topt = opts.topt;
+    const tuplesOnly = topt.tuplesOnly;
+    const startTable = topt.startTable;
+    const stopTable = topt.stopTable;
+    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 aligns = rs.fields.map((f) => NUMERIC_OIDS.has(f.dataTypeID) ? 'right' : 'left');
+    const cells = rs.rows.map((row) => row.map((cell) => renderCell(cell, nullPrint, topt.numericLocale)));
+    let buf = '';
+    if (startTable) {
+        buf += `<table border="${String(topt.border)}"`;
+        if (topt.tableAttr)
+            buf += ` ${topt.tableAttr}`;
+        buf += '>\n';
+        if (!tuplesOnly && title) {
+            buf += '  <caption>' + escapeHtml(title) + '</caption>\n';
+        }
+    }
+    let record = topt.prior + 1;
+    cells.forEach((row) => {
+        if (!tuplesOnly) {
+            buf += `\n  <tr><td colspan="2" align="center">Record ${String(record)}</td></tr>\n`;
+            record += 1;
+        }
+        else {
+            buf += '\n  <tr><td colspan="2">&nbsp;</td></tr>\n';
+        }
+        row.forEach((value, idx) => {
+            buf += '  <tr valign="top">\n';
+            buf += '    <th>' + escapeHtml(headers[idx]) + '</th>\n';
+            buf += `    <td align="${aligns[idx]}">`;
+            if (isWhitespaceOnly(value)) {
+                buf += '&nbsp; ';
+            }
+            else {
+                buf += escapeHtml(value);
+            }
+            buf += '</td>\n';
+            buf += '  </tr>\n';
+        });
+    });
+    if (stopTable) {
+        buf += '</table>\n';
+        // Expanded mode never emits the default "(N rows)" footer; only
+        // user-supplied footers appear (matches print_html_vertical).
+        if (!tuplesOnly && footers && footers.length > 0) {
+            buf += '<p>';
+            for (const f of footers) {
+                buf += escapeHtml(f) + '<br />\n';
+            }
+            buf += '</p>';
+        }
+        buf += '\n';
+    }
+    out.write(buf);
+    return Promise.resolve();
+};
+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 isWhitespaceOnly = (s) => {
+    if (s.length === 0)
+        return true;
+    for (const ch of s) {
+        if (ch !== ' ' && ch !== '\t')
+            return false;
+    }
+    return true;
+};
+const escapeHtml = (input) => {
+    // Upstream `html_escaped_print` walks the string byte-by-byte and
+    // converts leading spaces (per line) to `&nbsp;` so EXPLAIN output
+    // stays indented. We replicate that with a stateful pass.
+    let out = '';
+    let leadingSpace = true;
+    for (const ch of input) {
+        switch (ch) {
+            case '&':
+                out += '&amp;';
+                break;
+            case '<':
+                out += '&lt;';
+                break;
+            case '>':
+                out += '&gt;';
+                break;
+            case '"':
+                out += '&quot;';
+                break;
+            case '\n':
+                out += '<br />\n';
+                break;
+            case ' ':
+                out += leadingSpace ? '&nbsp;' : ' ';
+                break;
+            default:
+                out += ch;
+        }
+        if (ch !== ' ')
+            leadingSpace = false;
+    }
+    return out;
+};
+const renderCell = (cell, nullPrint, numericLocale) => {
+    if (cell === null || cell === undefined)
+        return nullPrint;
+    if (typeof cell === 'string') {
+        return formatNumericLocale(cell, numericLocale);
+    }
+    if (typeof cell === 'number' || typeof cell === 'bigint') {
+        return formatNumericLocale(cell.toString(), numericLocale);
+    }
+    if (typeof cell === 'boolean')
+        return cell ? 't' : 'f';
+    if (cell instanceof Date)
+        return cell.toISOString();
+    if (cell instanceof Uint8Array) {
+        let hex = '\\x';
+        for (const b of cell)
+            hex += b.toString(16).padStart(2, '0');
+        return hex;
+    }
+    return JSON.stringify(cell);
+};

package/psql/print/json.js

@@ -0,0 +1,96 @@
+/**
+ * JSON printer (used by `\gset`, `\gdesc`, and `--json` callers later
+ * in the WP plan).
+ *
+ * Output shape:
+ *   [{ "col": value, ... }, ...]
+ *
+ * - Default emits a single-line array; `topt.expanded === 'on'`
+ *   pretty-prints with two-space indentation.
+ * - SQL NULL → JSON null.
+ * - Numeric column data types (INT2/4/8, FLOAT4/8, NUMERIC) are
+ *   parsed to JSON numbers when the string is a finite JS number.
+ *   Anything outside `Number.isFinite` (large NUMERIC, NaN, Inf) is
+ *   preserved as a string so we never silently lose precision.
+ * - Booleans, dates, bytea, and unknown objects render as their
+ *   natural JSON forms (boolean / ISO string / hex-prefixed string /
+ *   stringified).
+ *
+ * Output is deterministic: column key order matches `rs.fields`; we
+ * never reorder rows.
+ */
+// PostgreSQL type OIDs for the numeric family that map cleanly to
+// JSON numbers. NUMERIC is included but guarded by isFinite().
+const NUMERIC_TYPE_OIDS = new Set([
+    21,
+    23,
+    20,
+    700,
+    701,
+    1700, // NUMERIC
+]);
+export const jsonPrinter = {
+    format: 'json',
+    printQuery(rs, opts, out) {
+        const pretty = opts.topt.expanded === 'on';
+        const objects = rs.rows.map((row) => {
+            const obj = {};
+            rs.fields.forEach((field, idx) => {
+                obj[field.name] = renderCell(row[idx], field.dataTypeID);
+            });
+            return obj;
+        });
+        const serialized = pretty
+            ? JSON.stringify(objects, null, 2)
+            : JSON.stringify(objects);
+        out.write(serialized + '\n');
+        return Promise.resolve();
+    },
+};
+const renderCell = (cell, dataTypeID) => {
+    if (cell === null || cell === undefined)
+        return null;
+    if (typeof cell === 'number') {
+        return Number.isFinite(cell) ? cell : cell.toString();
+    }
+    if (typeof cell === 'bigint') {
+        // Preserve as string when outside safe integer range.
+        const asNum = Number(cell);
+        return BigInt(asNum) === cell ? asNum : cell.toString();
+    }
+    if (typeof cell === 'boolean')
+        return cell;
+    if (cell instanceof Date)
+        return cell.toISOString();
+    if (cell instanceof Uint8Array) {
+        let hex = '\\x';
+        for (const b of cell)
+            hex += b.toString(16).padStart(2, '0');
+        return hex;
+    }
+    if (typeof cell === 'string') {
+        if (NUMERIC_TYPE_OIDS.has(dataTypeID)) {
+            const parsed = Number(cell);
+            if (Number.isFinite(parsed) && String(parsed) === normalize(cell)) {
+                return parsed;
+            }
+        }
+        return cell;
+    }
+    return cell;
+};
+/**
+ * Normalize a numeric string so the `String(parsed) === normalize(cell)`
+ * round-trip is stable: strip a single leading `+`, drop trailing zeros
+ * after a decimal point, drop a trailing bare decimal point, and drop a
+ * leading zero before a multi-digit integer.
+ */
+const normalize = (s) => {
+    let v = s;
+    if (v.startsWith('+'))
+        v = v.slice(1);
+    if (v.includes('.')) {
+        v = v.replace(/0+$/, '').replace(/\.$/, '');
+    }
+    return v;
+};