neonctl 2.28.0 → 2.29.1

package/dist/psql/command/cmd_copy.js

@@ -44,12 +44,12 @@
  *   - PSTDIN/PSTDOUT are treated as STDIN/STDOUT (no separate "psql stdin
  *     vs current input source" distinction — REPL plumbing isn't wired yet).
  */
-import { spawn } from 'node:child_process';
-import { createReadStream, createWriteStream, promises as fsPromises, } from 'node:fs';
-import { Buffer } from 'node:buffer';
-import { pumpReadable } from '../wire/copy.js';
-import { getPipelineState } from './cmd_pipeline.js';
-import { writeErr, writeOut } from './shared.js';
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import { createReadStream, createWriteStream, promises as fsPromises, } from "node:fs";
+import { pumpReadable } from "../wire/copy.js";
+import { getPipelineState } from "./cmd_pipeline.js";
+import { writeErr, writeOut } from "./shared.js";
 /**
  * Diagnostic emitted when the user tries to run `\copy` (or a raw COPY
  * statement) inside an active `\startpipeline` ... `\endpipeline` block.
@@ -58,8 +58,8 @@ import { writeErr, writeOut } from './shared.js';
  * the wire-layer abort path can reuse the same string and tests can match
  * via a single source of truth.
  */
-export const COPY_IN_PIPELINE_MSG = 'COPY in a pipeline is not supported, aborting connection';
-const WHITESPACE = ' \t\n\r';
+export const COPY_IN_PIPELINE_MSG = "COPY in a pipeline is not supported, aborting connection";
+const WHITESPACE = " \t\n\r";
 /**
  * Tokenise the next term of the `\copy` tail. Mirrors upstream's `strtokx`
  * call sites: each call passes a different combination of (delim chars,
@@ -83,7 +83,7 @@ const tokenize = (input, delim, quote, doubleQuoteEscape) => {
     while (i < n && WHITESPACE.includes(input[i]))
         i++;
     if (i >= n)
-        return { token: null, rest: '' };
+        return { token: null, rest: "" };
     // 2. Delimiter character returned as single-char token.
     if (delim.length > 0 && delim.includes(input[i])) {
         const token = input[i];
@@ -101,7 +101,7 @@ const tokenize = (input, delim, quote, doubleQuoteEscape) => {
         i++;
         while (i < n) {
             const c = input[i];
-            if (doubleQuoteEscape && c === '\\' && i + 1 < n) {
+            if (doubleQuoteEscape && c === "\\" && i + 1 < n) {
                 i += 2;
                 continue;
             }
@@ -146,7 +146,7 @@ const stripSingleQuotes = (token) => {
     if (token.length < 2 || !token.startsWith("'") || !token.endsWith("'")) {
         return token;
     }
-    let out = '';
+    let out = "";
     let i = 1;
     const end = token.length - 1;
     while (i < end) {
@@ -167,9 +167,9 @@ const stripSingleQuotes = (token) => {
  * Node doesn't expose `getpwnam` cleanly).
  */
 const expandTilde = (filePath) => {
-    if (!filePath.startsWith('~'))
+    if (!filePath.startsWith("~"))
         return filePath;
-    if (filePath === '~' || filePath.startsWith('~/')) {
+    if (filePath === "~" || filePath.startsWith("~/")) {
         const home = process.env.HOME ?? process.env.USERPROFILE;
         if (home === undefined)
             return filePath;
@@ -186,7 +186,7 @@ const expandTilde = (filePath) => {
  * by the dispatcher's `BackslashContext.rawArgs`).
  */
 export const parseSlashCopy = (input) => {
-    let beforeToFrom = '';
+    let beforeToFrom = "";
     let rest = input;
     let token;
     // Helper to keep the failure messages consistent with upstream.
@@ -194,18 +194,18 @@ export const parseSlashCopy = (input) => {
         ok: false,
         error: tok !== null && tok.length > 0
             ? `parse error at "${tok}"`
-            : 'parse error at end of line',
+            : "parse error at end of line",
     });
     // First token: optional BINARY, or table-name / "(" for subquery.
-    let r1 = tokenize(rest, '.,()', '"', false);
+    let r1 = tokenize(rest, ".,()", '"', false);
     token = r1.token;
     rest = r1.rest;
     if (token === null)
         return errAt(null);
     // Optional legacy BINARY keyword (pre-7.3 syntax). Re-emit then read next.
-    if (token.toLowerCase() === 'binary') {
+    if (token.toLowerCase() === "binary") {
         beforeToFrom += token;
-        r1 = tokenize(rest, '.,()', '"', false);
+        r1 = tokenize(rest, ".,()", '"', false);
         token = r1.token;
         rest = r1.rest;
         if (token === null)
@@ -213,62 +213,62 @@ export const parseSlashCopy = (input) => {
     }
     // `(query)` subquery form? Re-emit balanced-paren contents verbatim.
     let isSubquery = false;
-    if (token === '(') {
+    if (token === "(") {
         isSubquery = true;
         let parens = 1;
         while (parens > 0) {
-            beforeToFrom += ' ';
+            beforeToFrom += " ";
             beforeToFrom += token;
-            const r = tokenize(rest, '()', '"\'', true);
+            const r = tokenize(rest, "()", "\"'", true);
             token = r.token;
             rest = r.rest;
             if (token === null)
                 return errAt(null);
-            if (token === '(')
+            if (token === "(")
                 parens++;
-            else if (token === ')')
+            else if (token === ")")
                 parens--;
         }
     }
-    beforeToFrom += beforeToFrom.length > 0 ? ' ' : '';
+    beforeToFrom += beforeToFrom.length > 0 ? " " : "";
     beforeToFrom += token;
     // Next token: schema-separator `.`, column-list opener `(`, or FROM/TO.
-    let r2 = tokenize(rest, '.,()', '"', false);
+    let r2 = tokenize(rest, ".,()", '"', false);
     token = r2.token;
     rest = r2.rest;
     if (token === null)
         return errAt(null);
     // Schema-qualified `schema.table` — upstream just re-emits all three tokens.
-    if (token === '.') {
+    if (token === ".") {
         beforeToFrom += token;
-        r2 = tokenize(rest, '.,()', '"', false);
+        r2 = tokenize(rest, ".,()", '"', false);
         token = r2.token;
         rest = r2.rest;
         if (token === null)
             return errAt(null);
         beforeToFrom += token;
-        r2 = tokenize(rest, '.,()', '"', false);
+        r2 = tokenize(rest, ".,()", '"', false);
         token = r2.token;
         rest = r2.rest;
         if (token === null)
             return errAt(null);
     }
     // Parenthesised column list `(col1, col2, …)`.
-    if (token === '(') {
+    if (token === "(") {
         for (;;) {
-            beforeToFrom += ' ';
+            beforeToFrom += " ";
             beforeToFrom += token;
-            const r = tokenize(rest, '()', '"', false);
+            const r = tokenize(rest, "()", '"', false);
             token = r.token;
             rest = r.rest;
             if (token === null)
                 return errAt(null);
-            if (token === ')')
+            if (token === ")")
                 break;
         }
-        beforeToFrom += ' ';
+        beforeToFrom += " ";
         beforeToFrom += token;
-        r2 = tokenize(rest, '.,()', '"', false);
+        r2 = tokenize(rest, ".,()", '"', false);
         token = r2.token;
         rest = r2.rest;
         if (token === null)
@@ -276,24 +276,24 @@ export const parseSlashCopy = (input) => {
     }
     // FROM / TO keyword.
     let direction;
-    if (token.toLowerCase() === 'from') {
-        direction = 'from';
+    if (token.toLowerCase() === "from") {
+        direction = "from";
     }
-    else if (token.toLowerCase() === 'to') {
-        direction = 'to';
+    else if (token.toLowerCase() === "to") {
+        direction = "to";
     }
     else {
         return errAt(token);
     }
     // \copy (subquery) FROM is invalid — subqueries only make sense with TO.
-    if (isSubquery && direction === 'from') {
+    if (isSubquery && direction === "from") {
         return {
             ok: false,
-            error: 'cannot use COPY FROM with a (subquery) source',
+            error: "cannot use COPY FROM with a (subquery) source",
         };
     }
     // Filename / PROGRAM / STDIN / STDOUT / PSTDIN / PSTDOUT.
-    let r3 = tokenize(rest, ';', "'", false);
+    let r3 = tokenize(rest, ";", "'", false);
     token = r3.token;
     rest = r3.rest;
     if (token === null)
@@ -302,22 +302,24 @@ export const parseSlashCopy = (input) => {
     let program = false;
     let psqlInOut = false;
     const lower = token.toLowerCase();
-    if (lower === 'program') {
-        r3 = tokenize(rest, ';', "'", false);
+    if (lower === "program") {
+        r3 = tokenize(rest, ";", "'", false);
         token = r3.token;
         rest = r3.rest;
         if (token === null)
             return errAt(null);
-        if (!token.startsWith("'") || !token.endsWith("'") || token.length < 2) {
+        if (!token.startsWith("'") ||
+            !token.endsWith("'") ||
+            token.length < 2) {
             return errAt(token);
         }
         file = stripSingleQuotes(token);
         program = true;
     }
-    else if (lower === 'stdin' || lower === 'stdout') {
+    else if (lower === "stdin" || lower === "stdout") {
         file = null;
     }
-    else if (lower === 'pstdin' || lower === 'pstdout') {
+    else if (lower === "pstdin" || lower === "pstdout") {
         file = null;
         psqlInOut = true;
     }
@@ -351,8 +353,8 @@ export const parseSlashCopy = (input) => {
  * invisible to the server because that's what frontend-driven COPY is for.
  */
 const buildCopySql = (opts) => {
-    const tail = opts.direction === 'from' ? ' FROM STDIN ' : ' TO STDOUT ';
-    const after = opts.afterToFrom !== null ? opts.afterToFrom : '';
+    const tail = opts.direction === "from" ? " FROM STDIN " : " TO STDOUT ";
+    const after = opts.afterToFrom !== null ? opts.afterToFrom : "";
     return `COPY ${opts.beforeToFrom}${tail}${after}`.trimEnd();
 };
 /**
@@ -404,7 +406,7 @@ export const isCopyTextFormat = (afterToFrom) => {
     // stripped form will have collapsed quoted values to `''`.
     const m = /\bformat\s+(?:'([A-Za-z_]+)'|([A-Za-z_]+))/i.exec(afterToFrom);
     if (m) {
-        return (m[1] ?? m[2]).toLowerCase() === 'text';
+        return (m[1] ?? m[2]).toLowerCase() === "text";
     }
     return true;
 };
@@ -437,7 +439,7 @@ export const isCopyBinaryFormat = (beforeToFrom, afterToFrom) => {
     // FORMAT value may be optionally single-quoted in WITH (FORMAT 'binary').
     const m = /\bformat\s+(?:'([A-Za-z_]+)'|([A-Za-z_]+))/i.exec(afterToFrom);
     if (m) {
-        return (m[1] ?? m[2]).toLowerCase() === 'binary';
+        return (m[1] ?? m[2]).toLowerCase() === "binary";
     }
     return false;
 };
@@ -471,11 +473,11 @@ export const COPY_BINARY_SIGNATURE = Buffer.from([
  */
 export const validateCopyBinarySignature = (buf) => {
     if (buf.length < COPY_BINARY_SIGNATURE.length) {
-        return 'missing COPY binary signature (input too short)';
+        return "missing COPY binary signature (input too short)";
     }
     for (let i = 0; i < COPY_BINARY_SIGNATURE.length; i++) {
         if (buf[i] !== COPY_BINARY_SIGNATURE[i]) {
-            return 'COPY binary signature mismatch';
+            return "COPY binary signature mismatch";
         }
     }
     return null;
@@ -493,11 +495,11 @@ const parseCopyTagRows = (tag) => {
     return parseInt(m[1], 10);
 };
 const spawnProgram = (cmd, direction) => {
-    const child = spawn('sh', ['-c', cmd], {
+    const child = spawn("sh", ["-c", cmd], {
         stdio: [
-            direction === 'to' ? 'pipe' : 'inherit',
-            direction === 'from' ? 'pipe' : 'inherit',
-            'inherit',
+            direction === "to" ? "pipe" : "inherit",
+            direction === "from" ? "pipe" : "inherit",
+            "inherit",
         ],
     });
     // Capture the program's terminal status so the caller can surface a nonzero
@@ -505,17 +507,17 @@ const spawnProgram = (cmd, direction) => {
     // `close` carries (code, signal); `error` fires when the spawn itself
     // failed (e.g. sh missing).
     const closed = new Promise((resolve) => {
-        child.once('close', (code, signal) => {
+        child.once("close", (code, signal) => {
             resolve({ code, signal, error: null });
         });
-        child.once('error', (error) => {
+        child.once("error", (error) => {
             resolve({ code: null, signal: null, error });
         });
     });
     return {
         child,
-        readable: direction === 'from' ? child.stdout : null,
-        writable: direction === 'to' ? child.stdin : null,
+        readable: direction === "from" ? child.stdout : null,
+        writable: direction === "to" ? child.stdin : null,
         closed,
     };
 };
@@ -589,9 +591,9 @@ const pumpStdinWithEofMarker = async (readable, copyIn) => {
             if (settled)
                 return;
             settled = true;
-            readable.removeListener('data', onData);
-            readable.removeListener('end', onEnd);
-            readable.removeListener('error', onError);
+            readable.removeListener("data", onData);
+            readable.removeListener("end", onEnd);
+            readable.removeListener("error", onError);
             run().then(() => {
                 resolve(markerHit);
             }, (err) => {
@@ -615,7 +617,9 @@ const pumpStdinWithEofMarker = async (readable, copyIn) => {
             // across chunk boundaries and any non-UTF-8 client_encoding byte
             // (LATIN1/SJIS) into U+FFFD. stdin yields Buffers;
             // guard the rare string case without assuming a lossy re-encode.
-            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8');
+            const buf = Buffer.isBuffer(chunk)
+                ? chunk
+                : Buffer.from(chunk, "utf8");
             tail = tail.length === 0 ? buf : Buffer.concat([tail, buf]);
             let nl = tail.indexOf(0x0a); // '\n'
             while (nl !== -1) {
@@ -638,9 +642,9 @@ const pumpStdinWithEofMarker = async (readable, copyIn) => {
                     // Pause + remove listeners BEFORE unshifting so the post-marker
                     // bytes aren't re-emitted into our own data handler.
                     readable.pause();
-                    readable.removeListener('data', onData);
-                    readable.removeListener('end', onEnd);
-                    readable.removeListener('error', onError);
+                    readable.removeListener("data", onData);
+                    readable.removeListener("end", onEnd);
+                    readable.removeListener("error", onError);
                     if (leftover.length > 0) {
                         readable.unshift(leftover);
                     }
@@ -650,7 +654,9 @@ const pumpStdinWithEofMarker = async (readable, copyIn) => {
                         .then(() => {
                         resolve(true);
                     }, (err) => {
-                        reject(err instanceof Error ? err : new Error(String(err)));
+                        reject(err instanceof Error
+                            ? err
+                            : new Error(String(err)));
                     });
                     return;
                 }
@@ -701,9 +707,9 @@ const pumpStdinWithEofMarker = async (readable, copyIn) => {
                 throw err;
             });
         };
-        readable.on('data', onData);
-        readable.once('end', onEnd);
-        readable.once('error', onError);
+        readable.on("data", onData);
+        readable.once("end", onEnd);
+        readable.once("error", onError);
         // Trigger flowing mode in case the readable is paused.
         readable.resume();
     });
@@ -737,11 +743,11 @@ export const doCopy = async (conn, opts) => {
     let fromStdin = false;
     /** Cleanup callbacks run in `finally`. */
     const cleanups = [];
-    if (opts.direction === 'from') {
+    if (opts.direction === "from") {
         if (opts.file !== null) {
             if (opts.program) {
                 try {
-                    program = spawnProgram(opts.file, 'from');
+                    program = spawnProgram(opts.file, "from");
                 }
                 catch (err) {
                     return failWith(`could not execute command "${opts.file}": ${err instanceof Error ? err.message : String(err)}`);
@@ -776,7 +782,7 @@ export const doCopy = async (conn, opts) => {
                         resolve();
                         return;
                     }
-                    stream.once('close', () => {
+                    stream.once("close", () => {
                         resolve();
                     });
                     stream.destroy();
@@ -795,7 +801,7 @@ export const doCopy = async (conn, opts) => {
         if (opts.file !== null) {
             if (opts.program) {
                 try {
-                    program = spawnProgram(opts.file, 'to');
+                    program = spawnProgram(opts.file, "to");
                 }
                 catch (err) {
                     return failWith(`could not execute command "${opts.file}": ${err instanceof Error ? err.message : String(err)}`);
@@ -815,7 +821,9 @@ export const doCopy = async (conn, opts) => {
             else {
                 try {
                     // Reject if the path exists and is a directory.
-                    const stat = await fsPromises.stat(opts.file).catch(() => null);
+                    const stat = await fsPromises
+                        .stat(opts.file)
+                        .catch(() => null);
                     if (stat?.isDirectory()) {
                         return failWith(`${opts.file}: cannot copy from/to a directory`);
                     }
@@ -826,7 +834,7 @@ export const doCopy = async (conn, opts) => {
                 const stream = createWriteStream(opts.file);
                 // Trap the async open/write error synchronously so it can't crash the
                 // process; surfaced as a COPY failure after the drive.
-                stream.once('error', (e) => {
+                stream.once("error", (e) => {
                     fileWriteErrors.push(e);
                 });
                 writable = stream;
@@ -849,9 +857,9 @@ export const doCopy = async (conn, opts) => {
     // Drive the COPY.
     let tag = null;
     try {
-        if (opts.direction === 'from') {
+        if (opts.direction === "from") {
             if (readable === null) {
-                return failWith('no input stream for COPY FROM');
+                return failWith("no input stream for COPY FROM");
             }
             const copyIn = await conn.startCopyIn(sql);
             // STDIN honours the `\.` EOF marker for BOTH text and CSV (psql treats
@@ -869,7 +877,7 @@ export const doCopy = async (conn, opts) => {
         }
         else {
             if (writable === null) {
-                return failWith('no output stream for COPY TO');
+                return failWith("no output stream for COPY TO");
             }
             await drainCopyTo(conn, sql, writable);
             // A deferred open()/write() failure on the output file: report it as a
@@ -887,7 +895,7 @@ export const doCopy = async (conn, opts) => {
             program.writable?.end();
             const exit = await program.closed;
             // A program is only spawned when opts.file holds the command string.
-            const progErr = describeProgramExit(opts.file ?? '', exit);
+            const progErr = describeProgramExit(opts.file ?? "", exit);
             if (progErr !== null)
                 throw new Error(progErr);
         }
@@ -917,7 +925,7 @@ export const doCopy = async (conn, opts) => {
  */
 const readLastCopyTag = (conn) => {
     const maybe = conn.lastCopyTag;
-    if (typeof maybe === 'string')
+    if (typeof maybe === "string")
         return maybe;
     return null;
 };
@@ -931,13 +939,15 @@ const readLastCopyTag = (conn) => {
  * result-printing pipeline emits the tag.
  */
 export const cmdCopy = {
-    name: 'copy',
-    helpKey: 'copy',
+    name: "copy",
+    helpKey: "copy",
     async run(ctx) {
         if (!ctx.settings.db) {
-            ctx.settings.lastErrorResult = { message: 'no connection to the server' };
-            writeErr('\\copy: no connection to the server\n');
-            return { status: 'error' };
+            ctx.settings.lastErrorResult = {
+                message: "no connection to the server",
+            };
+            writeErr("\\copy: no connection to the server\n");
+            return { status: "error" };
         }
         // COPY is not supported inside a \startpipeline ... \endpipeline block:
         // upstream libpq aborts the connection with this exact diagnostic and
@@ -959,25 +969,25 @@ export const cmdCopy = {
             catch {
                 // best-effort; the connection may already be dead
             }
-            return { status: 'error' };
+            return { status: "error" };
         }
         const raw = ctx.restOfLine();
         if (raw.trim().length === 0) {
-            ctx.settings.lastErrorResult = { message: 'arguments required' };
-            writeErr('\\copy: arguments required\n');
-            return { status: 'error' };
+            ctx.settings.lastErrorResult = { message: "arguments required" };
+            writeErr("\\copy: arguments required\n");
+            return { status: "error" };
         }
         const parsed = parseSlashCopy(raw);
         if (!parsed.ok) {
             ctx.settings.lastErrorResult = { message: parsed.error };
             writeErr(`\\copy: ${parsed.error}\n`);
-            return { status: 'error' };
+            return { status: "error" };
         }
         const result = await doCopy(ctx.settings.db, parsed.value);
         if (!result.ok) {
             ctx.settings.lastErrorResult = { message: result.error };
             writeErr(`\\copy: ${result.error}\n`);
-            return { status: 'error' };
+            return { status: "error" };
         }
         // Print the upstream-style command tag (e.g. "COPY 17") so users see the
         // same summary as `psql`. If the connection didn't surface a tag, just
@@ -990,7 +1000,7 @@ export const cmdCopy = {
         // print path, so the tag has nowhere to land. Mirror that here: only
         // print when the destination is a file, a program, or when the COPY is
         // a FROM (where the data flowed *into* the server, not out to stdout).
-        const suppressTag = parsed.value.direction === 'to' &&
+        const suppressTag = parsed.value.direction === "to" &&
             parsed.value.file === null &&
             !parsed.value.program;
         if (!suppressTag) {
@@ -1002,10 +1012,10 @@ export const cmdCopy = {
                 writeOut(`${result.tag}\n`);
             }
             else {
-                writeOut('COPY\n');
+                writeOut("COPY\n");
             }
         }
-        return { status: 'ok' };
+        return { status: "ok" };
     },
 };
 /**
@@ -1022,4 +1032,4 @@ export { buildCopySql, pumpStdinWithEofMarker };
  * tests can feed a `Buffer` to {@link doCopy} without re-implementing the
  * Readable shim.
  */
-export const toBuffer = (s) => Buffer.from(s, 'utf8');
+export const toBuffer = (s) => Buffer.from(s, "utf8");