neonctl 2.28.0 → 2.29.1

package/dist/psql/io/history.js

@@ -33,10 +33,10 @@
  *     bash/readline behaviour where the user's literal input is what gets
  *     deduped, not the escaped on-disk form.
  */
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 /** psql's compiled-in default for HISTSIZE (see `src/bin/psql/settings.h`). */
 const DEFAULT_HISTSIZE = 500;
 /**
@@ -78,7 +78,7 @@ export const clearHistory = () => {
     inMemoryHistory = [];
 };
 /** Encode a single in-memory entry to the on-disk libreadline form. */
-const encodeEntry = (entry) => entry.replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+const encodeEntry = (entry) => entry.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
 /**
  * Decode a single on-disk libreadline line back to its in-memory form.
  *
@@ -87,23 +87,23 @@ const encodeEntry = (entry) => entry.replace(/\\/g, '\\\\').replace(/\n/g, '\\n'
  * a stray backslash at the end of the file does not eat the next entry.
  */
 const decodeEntry = (line) => {
-    let out = '';
+    let out = "";
     for (let i = 0; i < line.length; i++) {
         const c = line.charCodeAt(i);
         if (c === 0x5c /* '\\' */ && i + 1 < line.length) {
             const next = line[i + 1];
-            if (next === 'n') {
-                out += '\n';
+            if (next === "n") {
+                out += "\n";
                 i++;
                 continue;
             }
-            if (next === 'r') {
-                out += '\r';
+            if (next === "r") {
+                out += "\r";
                 i++;
                 continue;
             }
-            if (next === '\\') {
-                out += '\\';
+            if (next === "\\") {
+                out += "\\";
                 i++;
                 continue;
             }
@@ -119,8 +119,8 @@ const decodeEntry = (line) => {
  * Mirrors `pg_send_history()`'s filter in `input.c`.
  */
 const shouldIgnore = (entry, prev, histcontrol) => {
-    const ignoreSpace = histcontrol === 'ignorespace' || histcontrol === 'ignoreboth';
-    const ignoreDups = histcontrol === 'ignoredups' || histcontrol === 'ignoreboth';
+    const ignoreSpace = histcontrol === "ignorespace" || histcontrol === "ignoreboth";
+    const ignoreDups = histcontrol === "ignoredups" || histcontrol === "ignoreboth";
     if (ignoreSpace && entry.length > 0 && /^\s/.test(entry))
         return true;
     if (ignoreDups && prev !== undefined && prev === entry)
@@ -140,13 +140,13 @@ const shouldIgnore = (entry, prev, histcontrol) => {
 export const loadHistory = async (filePath) => {
     let raw;
     try {
-        raw = await fs.readFile(filePath, 'utf8');
+        raw = await fs.readFile(filePath, "utf8");
     }
     catch (err) {
         if (err &&
-            typeof err === 'object' &&
-            'code' in err &&
-            err.code === 'ENOENT') {
+            typeof err === "object" &&
+            "code" in err &&
+            err.code === "ENOENT") {
             return [];
         }
         throw err;
@@ -155,13 +155,13 @@ export const loadHistory = async (filePath) => {
     // doesn't produce a phantom empty entry. Don't strip more than one — a
     // blank line in the middle of the file represents an entry that was
     // literally the empty string (rare but possible), and we round-trip it.
-    if (raw.endsWith('\n'))
+    if (raw.endsWith("\n"))
         raw = raw.slice(0, -1);
     if (raw.length === 0)
         return [];
     const entries = [];
-    for (const line of raw.split('\n')) {
-        if (line.startsWith('#'))
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("#"))
             continue;
         entries.push(decodeEntry(line));
     }
@@ -183,12 +183,12 @@ export const loadHistory = async (filePath) => {
  *     when ignoredups is in effect — typical history files are well
  *     under 1 MiB.
  */
-export const appendHistory = async (filePath, entry, histcontrol = 'none') => {
-    if (histcontrol === 'ignoredups' ||
-        histcontrol === 'ignoreboth' ||
-        histcontrol === 'ignorespace') {
+export const appendHistory = async (filePath, entry, histcontrol = "none") => {
+    if (histcontrol === "ignoredups" ||
+        histcontrol === "ignoreboth" ||
+        histcontrol === "ignorespace") {
         let prev;
-        if (histcontrol === 'ignoredups' || histcontrol === 'ignoreboth') {
+        if (histcontrol === "ignoredups" || histcontrol === "ignoreboth") {
             const existing = await loadHistory(filePath);
             prev = existing[existing.length - 1];
         }
@@ -200,7 +200,7 @@ export const appendHistory = async (filePath, entry, histcontrol = 'none') => {
     // lock-step under HISTCONTROL. Recording happens AFTER the ignore check
     // so an ignored line is absent from both.
     recordHistory(entry);
-    await fs.appendFile(filePath, encodeEntry(entry) + '\n', 'utf8');
+    await fs.appendFile(filePath, encodeEntry(entry) + "\n", "utf8");
 };
 /**
  * Trim the history file to its last `maxLines` entries.
@@ -221,9 +221,9 @@ export const truncateHistory = async (filePath, maxLines) => {
         }
         catch (err) {
             if (err &&
-                typeof err === 'object' &&
-                'code' in err &&
-                err.code === 'ENOENT') {
+                typeof err === "object" &&
+                "code" in err &&
+                err.code === "ENOENT") {
                 return;
             }
             throw err;
@@ -234,11 +234,11 @@ export const truncateHistory = async (filePath, maxLines) => {
     if (entries.length <= maxLines)
         return;
     const kept = entries.slice(entries.length - maxLines);
-    const body = kept.map(encodeEntry).join('\n') + '\n';
+    const body = kept.map(encodeEntry).join("\n") + "\n";
     const dir = path.dirname(filePath);
     const base = path.basename(filePath);
     const tmpPath = path.join(dir, `.${base}.${randomUUID()}.tmp`);
-    await fs.writeFile(tmpPath, body, { encoding: 'utf8', mode: 0o600 });
+    await fs.writeFile(tmpPath, body, { encoding: "utf8", mode: 0o600 });
     try {
         await fs.rename(tmpPath, filePath);
     }
@@ -269,16 +269,16 @@ export const defaultHistoryPath = (env = process.env) => {
     const explicit = env.PSQL_HISTORY;
     if (explicit !== undefined && explicit.length > 0)
         return explicit;
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
         const appdata = env.APPDATA;
         if (appdata !== undefined && appdata.length > 0) {
-            return path.join(appdata, 'postgresql', 'psql_history');
+            return path.join(appdata, "postgresql", "psql_history");
         }
         // Fall through to homedir() if APPDATA isn't set; matches psql's
         // graceful degradation on a minimally-configured Windows session.
     }
     const home = env.HOME ?? os.homedir();
-    return path.join(home, '.psql_history');
+    return path.join(home, ".psql_history");
 };
 /**
  * Resolve the effective HISTSIZE: the `HISTSIZE` env var (if a
@@ -290,7 +290,7 @@ export const defaultHistoryPath = (env = process.env) => {
  */
 export const resolveHistSize = (env = process.env) => {
     const raw = env.HISTSIZE;
-    if (raw === undefined || raw === '')
+    if (raw === undefined || raw === "")
         return DEFAULT_HISTSIZE;
     const n = Number(raw);
     if (!Number.isInteger(n) || n < 0)

package/dist/psql/io/input.js

@@ -17,11 +17,11 @@
  * unit tests; production callers use {@link readLine} with the process
  * defaults.
  */
-import { createInterface } from 'node:readline';
+import { createInterface } from "node:readline";
 /** True when `stream` is a TTY whose echo we can suppress via raw mode. */
 const isRawCapableTty = (stream) => {
     const s = stream;
-    return Boolean(s.isTTY) && typeof s.setRawMode === 'function';
+    return Boolean(s.isTTY) && typeof s.setRawMode === "function";
 };
 /**
  * Read one line of input, optionally suppressing echo.
@@ -61,11 +61,11 @@ const readEchoLine = (prompt, input, output) => {
         // Resolve on the first complete line. Closing without one (EOF) yields ''.
         // We don't rely on `line` firing before `close`: whichever lands first
         // wins, and a buffered final line is delivered as a `line` event.
-        rl.on('line', (l) => {
+        rl.on("line", (l) => {
             settle(l);
         });
-        rl.on('close', () => {
-            settle('');
+        rl.on("close", () => {
+            settle("");
         });
     });
 };
@@ -81,33 +81,33 @@ const readNoEchoTty = (prompt, input, output) => {
             output.write(prompt);
         input.setRawMode(true);
         input.resume();
-        input.setEncoding('utf8');
-        let buf = '';
+        input.setEncoding("utf8");
+        let buf = "";
         const finish = (result) => {
             input.setRawMode(false);
             input.pause();
-            input.removeListener('data', onData);
+            input.removeListener("data", onData);
             // Terminate the (un-echoed) line the user couldn't see themselves type.
-            output.write('\n');
+            output.write("\n");
             resolve(result);
         };
         const onData = (chunk) => {
             for (const ch of chunk) {
-                if (ch === '\n' || ch === '\r') {
+                if (ch === "\n" || ch === "\r") {
                     finish(buf);
                     return;
                 }
-                if (ch === '') {
+                if (ch === "") {
                     // Ctrl-C: cancel, return nothing.
-                    finish('');
+                    finish("");
                     return;
                 }
-                if (ch === '') {
+                if (ch === "") {
                     // Ctrl-D (EOF): return what we have.
                     finish(buf);
                     return;
                 }
-                if (ch === '' || ch === '\b') {
+                if (ch === "" || ch === "\b") {
                     // DEL / Backspace: drop the last character.
                     buf = buf.slice(0, -1);
                     continue;
@@ -115,6 +115,6 @@ const readNoEchoTty = (prompt, input, output) => {
                 buf += ch;
             }
         };
-        input.on('data', onData);
+        input.on("data", onData);
     });
 };

package/dist/psql/io/lineEditor/buffer.js

@@ -31,7 +31,7 @@ const toCodePoints = (s) => Array.from(s);
  * Pure line buffer plus kill ring plus undo. Used by the keymap layer.
  */
 export class LineBuffer {
-    constructor(initial = '', cursor) {
+    constructor(initial = "", cursor) {
         /** One code point per element. */
         this.chars = [];
         /** Code-point index in `[0, chars.length]`. */
@@ -41,7 +41,7 @@ export class LineBuffer {
         /** Index into killRing for the next yank-pop (^Y / Alt-Y). */
         this.yankIndex = -1;
         /** Direction of the previous kill so consecutive kills concatenate. */
-        this.lastKill = 'none';
+        this.lastKill = "none";
         /** Snapshots for ^_ / undo. */
         this.undoStack = [];
         this.chars = toCodePoints(initial);
@@ -52,7 +52,7 @@ export class LineBuffer {
     // Accessors
     // -------------------------------------------------------------------------
     get text() {
-        return this.chars.join('');
+        return this.chars.join("");
     }
     get cursor() {
         return this._cursor;
@@ -66,7 +66,7 @@ export class LineBuffer {
     restore(snap) {
         this.chars = toCodePoints(snap.text);
         this._cursor = this.clampCursor(snap.cursor);
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     /**
      * Replace the entire buffer in one go. Used when navigating history or
@@ -77,7 +77,7 @@ export class LineBuffer {
         this.chars = toCodePoints(text);
         this._cursor =
             cursor === undefined ? this.chars.length : this.clampCursor(cursor);
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     // -------------------------------------------------------------------------
     // Cursor movement (all in code points, never bytes / UTF-16 units)
@@ -85,20 +85,20 @@ export class LineBuffer {
     moveLeft() {
         if (this._cursor > 0)
             this._cursor--;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     moveRight() {
         if (this._cursor < this.chars.length)
             this._cursor++;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     moveHome() {
         this._cursor = 0;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     moveEnd() {
         this._cursor = this.chars.length;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     /**
      * Move left over one word. Word ≙ run of alphanumerics. Skip the
@@ -113,7 +113,7 @@ export class LineBuffer {
         while (i > 0 && isWordChar(this.chars[i - 1]))
             i--;
         this._cursor = i;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     moveWordRight() {
         let i = this._cursor;
@@ -122,7 +122,7 @@ export class LineBuffer {
         while (i < this.chars.length && isWordChar(this.chars[i]))
             i++;
         this._cursor = i;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     // -------------------------------------------------------------------------
     // Insertion / deletion
@@ -135,7 +135,7 @@ export class LineBuffer {
         const cps = toCodePoints(s);
         this.chars.splice(this._cursor, 0, ...cps);
         this._cursor += cps.length;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     /** Backspace: delete the code point to the left of cursor. */
     deleteLeft() {
@@ -144,7 +144,7 @@ export class LineBuffer {
         this.pushUndo();
         this.chars.splice(this._cursor - 1, 1);
         this._cursor--;
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     /** Delete the code point to the right of cursor. */
     deleteRight() {
@@ -152,7 +152,7 @@ export class LineBuffer {
             return;
         this.pushUndo();
         this.chars.splice(this._cursor, 1);
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     // -------------------------------------------------------------------------
     // Kill ring operations
@@ -162,19 +162,19 @@ export class LineBuffer {
         if (this._cursor === this.chars.length)
             return;
         this.pushUndo();
-        const killed = this.chars.slice(this._cursor).join('');
+        const killed = this.chars.slice(this._cursor).join("");
         this.chars.length = this._cursor;
-        this.recordKill(killed, 'forward');
+        this.recordKill(killed, "forward");
     }
     /** ^U: kill from start-of-line to cursor. */
     killToStart() {
         if (this._cursor === 0)
             return;
         this.pushUndo();
-        const killed = this.chars.slice(0, this._cursor).join('');
+        const killed = this.chars.slice(0, this._cursor).join("");
         this.chars.splice(0, this._cursor);
         this._cursor = 0;
-        this.recordKill(killed, 'backward');
+        this.recordKill(killed, "backward");
     }
     /** ^W: kill the word (backward) to the left of cursor. */
     killWordLeft() {
@@ -188,10 +188,10 @@ export class LineBuffer {
         if (i === this._cursor)
             return;
         this.pushUndo();
-        const killed = this.chars.slice(i, this._cursor).join('');
+        const killed = this.chars.slice(i, this._cursor).join("");
         this.chars.splice(i, this._cursor - i);
         this._cursor = i;
-        this.recordKill(killed, 'backward');
+        this.recordKill(killed, "backward");
     }
     /** M-d: kill the word (forward) starting at cursor. */
     killWordRight() {
@@ -205,9 +205,9 @@ export class LineBuffer {
         if (i === this._cursor)
             return;
         this.pushUndo();
-        const killed = this.chars.slice(this._cursor, i).join('');
+        const killed = this.chars.slice(this._cursor, i).join("");
         this.chars.splice(this._cursor, i - this._cursor);
-        this.recordKill(killed, 'forward');
+        this.recordKill(killed, "forward");
     }
     /** ^Y: yank most recent kill at cursor. No-op if ring is empty. */
     yank() {
@@ -240,7 +240,7 @@ export class LineBuffer {
     }
     /** Reset the kill-merge tracker. Called when a non-kill action runs. */
     resetKillTracking() {
-        this.lastKill = 'none';
+        this.lastKill = "none";
     }
     /** Test helper / introspection. */
     getKillRing() {
@@ -263,7 +263,7 @@ export class LineBuffer {
             return false;
         this.chars = toCodePoints(snap.text);
         this._cursor = this.clampCursor(snap.cursor);
-        this.lastKill = 'none';
+        this.lastKill = "none";
         return true;
     }
     // -------------------------------------------------------------------------
@@ -283,7 +283,9 @@ export class LineBuffer {
             // Merge with the previous kill so consecutive ^K / ^W feel like one
             // logical kill in the yank ring.
             this.killRing[0] =
-                dir === 'forward' ? this.killRing[0] + text : text + this.killRing[0];
+                dir === "forward"
+                    ? this.killRing[0] + text
+                    : text + this.killRing[0];
         }
         else {
             this.killRing.unshift(text);

package/dist/psql/io/lineEditor/complete.js

@@ -68,7 +68,7 @@ export class CompletionState {
             this.cycleIndex = -1;
             this.cycleLen = 0;
             if (res.candidates.length === 0)
-                return { kind: 'bell' };
+                return { kind: "bell" };
             if (res.candidates.length === 1) {
                 // Mirror upstream readline: a unique completion gets a trailing space
                 // (rl_completion_append_character defaults to ' ') unless the result
@@ -76,10 +76,10 @@ export class CompletionState {
                 // is expected to continue typing through) or the candidate itself
                 // already ends in a punctuator that shouldn't be followed by a space.
                 const cand = res.candidates[0];
-                const text = shouldAppendSpace(cand, res) ? cand + ' ' : cand;
+                const text = shouldAppendSpace(cand, res) ? cand + " " : cand;
                 replaceBeforeCursor(buffer, res.replaceLength, text);
                 this.reset();
-                return { kind: 'inserted' };
+                return { kind: "inserted" };
             }
             // Multiple candidates: insert the common prefix when it differs from
             // what's currently in the buffer at that position. The diff can be
@@ -94,13 +94,13 @@ export class CompletionState {
             // so the cycle path knows how many code points to overwrite when it
             // swaps in the next candidate.
             this.cycleLen = countCodePoints(res.commonPrefix);
-            return { kind: 'inserted' };
+            return { kind: "inserted" };
         }
         // We already have a result, and the second Tab arrived in time.
         this.tabCount++;
         if (this.tabCount === 2 && elapsed <= DOUBLE_TAP_MS) {
             // List the candidates.
-            return { kind: 'list', candidates: this.result.candidates.slice() };
+            return { kind: "list", candidates: this.result.candidates.slice() };
         }
         // Third or later: cycle.
         const cands = this.result.candidates;
@@ -108,7 +108,7 @@ export class CompletionState {
         const cand = cands[this.cycleIndex];
         replaceBeforeCursor(buffer, this.cycleLen, cand);
         this.cycleLen = countCodePoints(cand);
-        return { kind: 'cycled', candidate: cand };
+        return { kind: "cycled", candidate: cand };
     }
 }
 /**
@@ -146,9 +146,9 @@ const shouldAppendSpace = (candidate, result) => {
     if (candidate.length === 0)
         return false;
     const last = candidate[candidate.length - 1];
-    if (last === ' ' || last === '\t' || last === '\n')
+    if (last === " " || last === "\t" || last === "\n")
         return false;
-    if (last === '.' || last === '/' || last === '(')
+    if (last === "." || last === "/" || last === "(")
         return false;
     if (last === '"') {
         // Even count means quotes are balanced (e.g. `"mixedName"`) — completed
@@ -174,8 +174,8 @@ const countChar = (s, ch) => {
 // Listing helper: format candidates in column layout for display.
 // ---------------------------------------------------------------------------
 /** ANSI reverse-video escape (SGR 7) used to mark the active candidate. */
-const SGR_REVERSE = '\x1b[7m';
-const SGR_NO_REVERSE = '\x1b[27m';
+const SGR_REVERSE = "\x1b[7m";
+const SGR_NO_REVERSE = "\x1b[27m";
 /**
  * Lay out candidates into a multi-column block. Returns the formatted
  * string (without a trailing newline — caller decides). Columns are sized
@@ -190,7 +190,7 @@ const SGR_NO_REVERSE = '\x1b[27m';
  */
 export const formatCandidates = (candidates, termWidth, highlightIndex) => {
     if (candidates.length === 0)
-        return '';
+        return "";
     const maxLen = candidates.reduce((m, c) => Math.max(m, c.length), 0);
     const colWidth = maxLen + 2;
     const cols = Math.max(1, Math.floor(termWidth / colWidth));
@@ -208,20 +208,20 @@ export const formatCandidates = (candidates, termWidth, highlightIndex) => {
             if (idx >= candidates.length)
                 break;
             const cand = candidates[idx];
-            const padded = cand + ' '.repeat(colWidth - cand.length);
+            const padded = cand + " ".repeat(colWidth - cand.length);
             if (idx === hl) {
                 // Wrap only the candidate text, not the gutter spaces, so adjacent
                 // columns don't get a colored stripe between them.
                 parts.push(SGR_REVERSE +
                     cand +
                     SGR_NO_REVERSE +
-                    ' '.repeat(colWidth - cand.length));
+                    " ".repeat(colWidth - cand.length));
             }
             else {
                 parts.push(padded);
             }
         }
-        lines.push(parts.join('').trimEnd());
+        lines.push(parts.join("").trimEnd());
     }
-    return lines.join('\n');
+    return lines.join("\n");
 };