neonctl 2.27.1 → 2.29.0

package/dist/psql/command/dispatch.js

@@ -30,19 +30,19 @@
  * delegates to `settings.vars`. Modes that disable substitution (`no-vars`)
  * naturally fall through to the scanner's existing behaviour.
  */
-import { scanSlashArgs } from '../scanner/slash.js';
-import { cmdCd, cmdCopyright, cmdEcho, cmdEdit, cmdErrverbose, cmdGetenv, cmdHelpSQL, cmdPrompt, cmdQecho, cmdQuit, cmdReset, cmdS, cmdSet, cmdSetenv, cmdShell, cmdSlashHelp, cmdTiming, cmdUnset, cmdWarn, } from './cmd_meta.js';
-import { cmdA, cmdC, cmdEncoding, cmdF, cmdH, cmdPset, cmdT, cmdTitleAttr, cmdX, } from './cmd_format.js';
-import { registerIoCommands } from './cmd_io.js';
-import { registerConnectCommands } from './cmd_connect.js';
-import { registerCopyCommands } from './cmd_copy.js';
-import { registerDescribeCommands } from './cmd_describe.js';
-import { registerPipelineCommands } from './cmd_pipeline.js';
-import { registerMiscCommands } from './cmd_misc.js';
-import { registerLargeObjectCommands } from './cmd_lo.js';
-import { registerShowCommands } from './cmd_show.js';
-import { isCommandRestricted, registerRestrictCommands, wrapRestrictedCommands, } from './cmd_restrict.js';
-import { writeErr } from './shared.js';
+import { scanSlashArgs } from "../scanner/slash.js";
+import { registerConnectCommands } from "./cmd_connect.js";
+import { registerCopyCommands } from "./cmd_copy.js";
+import { registerDescribeCommands } from "./cmd_describe.js";
+import { cmdA, cmdC, cmdEncoding, cmdF, cmdH, cmdPset, cmdT, cmdTitleAttr, cmdX, } from "./cmd_format.js";
+import { registerIoCommands } from "./cmd_io.js";
+import { registerLargeObjectCommands } from "./cmd_lo.js";
+import { cmdCd, cmdCopyright, cmdEcho, cmdEdit, cmdErrverbose, cmdGetenv, cmdHelpSQL, cmdPrompt, cmdQecho, cmdQuit, cmdReset, cmdS, cmdSet, cmdSetenv, cmdShell, cmdSlashHelp, cmdTiming, cmdUnset, cmdWarn, } from "./cmd_meta.js";
+import { registerMiscCommands } from "./cmd_misc.js";
+import { registerPipelineCommands } from "./cmd_pipeline.js";
+import { isCommandRestricted, registerRestrictCommands, wrapRestrictedCommands, } from "./cmd_restrict.js";
+import { registerShowCommands } from "./cmd_show.js";
+import { writeErr } from "./shared.js";
 /**
  * Concrete `BackslashRegistry`: a primary-name → spec map plus a parallel
  * alias → primary-name map so lookups stay O(1).
@@ -103,7 +103,7 @@ export const makeContext = (opts) => {
     let cursor = 0;
     const rawArgs = opts.rawArgs;
     const varLookup = (name) => opts.settings.vars.get(name);
-    const nextArg = (mode = 'normal') => {
+    const nextArg = (mode = "normal") => {
         // Find the next non-whitespace byte from the cursor; we use it both to
         // know whether anything remains and as the basis for span tracking.
         let i = cursor;
@@ -111,7 +111,7 @@ export const makeContext = (opts) => {
             i++;
         if (i >= rawArgs.length)
             return null;
-        if (mode === 'whole-line') {
+        if (mode === "whole-line") {
             const tail = rawArgs.slice(i);
             cursor = rawArgs.length;
             return tail;
@@ -162,7 +162,7 @@ export const makeContext = (opts) => {
  * past the original `:name` form regardless of expansion size.
  */
 const consumedSpan = (tail, mode, varLookup) => {
-    if (mode === 'whole-line')
+    if (mode === "whole-line")
         return tail.length;
     let i = 0;
     // Skip leading whitespace inside the tail (already trimmed by caller, but
@@ -170,16 +170,16 @@ const consumedSpan = (tail, mode, varLookup) => {
     while (i < tail.length && /[\s]/.test(tail[i]))
         i++;
     // filepipe special: a leading `|` slurps to EOL.
-    if (mode === 'filepipe' && tail[i] === '|')
+    if (mode === "filepipe" && tail[i] === "|")
         return tail.length;
     while (i < tail.length) {
         const c = tail[i];
-        if (/[\s]/.test(c) || c === '\\')
+        if (/[\s]/.test(c) || c === "\\")
             break;
         if (c === "'") {
             i++;
             while (i < tail.length) {
-                if (tail[i] === '\\' && i + 1 < tail.length) {
+                if (tail[i] === "\\" && i + 1 < tail.length) {
                     i += 2;
                     continue;
                 }
@@ -203,15 +203,15 @@ const consumedSpan = (tail, mode, varLookup) => {
                 i++;
             continue;
         }
-        if (c === '`') {
+        if (c === "`") {
             i++;
-            while (i < tail.length && tail[i] !== '`')
+            while (i < tail.length && tail[i] !== "`")
                 i++;
             if (i < tail.length)
                 i++;
             continue;
         }
-        if (c === ':' && mode !== 'no-vars') {
+        if (c === ":" && mode !== "no-vars") {
             // :"name" / :'name' / :name — advance past the source form. We don't
             // actually call varLookup here; we just measure the lexical span.
             void varLookup;
@@ -248,14 +248,14 @@ const consumedSpan = (tail, mode, varLookup) => {
 export const dispatchBackslash = async (registry, cmdName, ctx) => {
     const spec = registry.lookup(cmdName);
     if (!spec)
-        return { status: 'error' };
+        return { status: "error" };
     // PG 18: refuse shell/filesystem-touching commands while restricted.
     // We check against the resolved *primary* name so aliases like
     // `\write` → `w` are caught.
     if (isCommandRestricted(ctx.settings, spec.name)) {
         writeErr(`\\${cmdName}: command is not allowed in restricted mode; ` +
             `use \\unrestrict to leave restricted mode\n`);
-        return { status: 'error' };
+        return { status: "error" };
     }
     return spec.run(ctx);
 };
@@ -310,8 +310,8 @@ export const defaultRegistry = () => {
     // shim. (In an active branch this makes `\html` a silent no-op rather than
     // upstream's "invalid command", but no test exercises that path.)
     r.register({
-        name: 'html',
-        run: () => Promise.resolve({ status: 'ok' }),
+        name: "html",
+        run: () => Promise.resolve({ status: "ok" }),
     });
     // Format.
     r.register(cmdA);

package/dist/psql/command/shared.js

@@ -31,23 +31,23 @@ export const parseBool = (raw) => {
         return null;
     const lower = raw.toLowerCase();
     const startsWith = (target) => lower.length <= target.length && target.startsWith(lower);
-    if (startsWith('true'))
+    if (startsWith("true"))
         return true;
-    if (startsWith('false'))
+    if (startsWith("false"))
         return false;
-    if (startsWith('yes'))
+    if (startsWith("yes"))
         return true;
-    if (startsWith('no'))
+    if (startsWith("no"))
         return false;
     if (lower.length >= 2) {
-        if ('on'.startsWith(lower))
+        if ("on".startsWith(lower))
             return true;
-        if ('off'.startsWith(lower))
+        if ("off".startsWith(lower))
             return false;
     }
-    if (raw === '1')
+    if (raw === "1")
         return true;
-    if (raw === '0')
+    if (raw === "0")
         return false;
     return null;
 };
@@ -60,12 +60,12 @@ export const parseTriple = (raw) => {
     // bool prefixes were inverted (review: minor divergences).
     const b = parseBool(raw);
     if (b === true)
-        return 'on';
+        return "on";
     if (b === false)
-        return 'off';
-    if ('auto'.startsWith(lower))
-        return 'auto';
-    if ('toggle'.startsWith(lower))
-        return 'toggle';
+        return "off";
+    if ("auto".startsWith(lower))
+        return "auto";
+    if ("toggle".startsWith(lower))
+        return "toggle";
     return null;
 };

package/dist/psql/complete/filenames.js

@@ -19,8 +19,8 @@
  * fires; partial multi-candidate prefixes leave the closing quote off so
  * the user can keep typing.
  */
-import { readdirSync, statSync } from 'node:fs';
-import { join, basename, dirname } from 'node:path';
+import { readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 /**
  * Enumerate filesystem entries matching the partial path the user typed.
  *
@@ -45,14 +45,14 @@ export const completeFilenames = (currentWord, quoteCtx, cwd = process.cwd()) =>
     }
     // Split into dir + basename prefix. A trailing `/` means "enumerate this
     // dir" and basename prefix is empty.
-    const lastSlash = raw.lastIndexOf('/');
-    const dirPart = lastSlash === -1 ? '' : raw.slice(0, lastSlash + 1);
+    const lastSlash = raw.lastIndexOf("/");
+    const dirPart = lastSlash === -1 ? "" : raw.slice(0, lastSlash + 1);
     const basePrefix = lastSlash === -1 ? raw : raw.slice(lastSlash + 1);
     // Resolve the directory to scan. Empty `dirPart` → cwd; otherwise it's
     // taken relative to cwd (or absolute if starts with `/`).
-    const scanDir = dirPart === ''
+    const scanDir = dirPart === ""
         ? cwd
-        : dirPart.startsWith('/')
+        : dirPart.startsWith("/")
             ? dirPart
             : join(cwd, dirPart);
     let entries;
@@ -80,10 +80,10 @@ export const completeFilenames = (currentWord, quoteCtx, cwd = process.cwd()) =>
         catch {
             // Broken symlink etc. — treat as regular file.
         }
-        const full = dirPart + entry + (isDir ? '/' : '');
+        const full = dirPart + entry + (isDir ? "/" : "");
         candidates.push(full);
     }
-    if (quoteCtx === 'none') {
+    if (quoteCtx === "none") {
         // Bare paths. Preserve any opening single quote the user already typed
         // (rare for the no-quote contexts, but harmless to mirror).
         if (hadOpeningSingleQuote) {
@@ -95,7 +95,7 @@ export const completeFilenames = (currentWord, quoteCtx, cwd = process.cwd()) =>
     // line editor's `shouldAppendSpace` checks quote balance — unique
     // candidates close the quote (so `'...'` balances → trailing space
     // fires), multi-candidate common prefixes leave the closing quote off.
-    if (candidates.length === 1 && !candidates[0].endsWith('/')) {
+    if (candidates.length === 1 && !candidates[0].endsWith("/")) {
         // Unique file (not directory): close the quote so the trailing space
         // fires. Opening quote: re-add if user typed it, else add ourselves.
         return ["'" + candidates[0] + "'"];
@@ -118,18 +118,18 @@ export const isCopyFromOrTo = (prevWords) => {
     // Walk from the end backward: the immediate prev word must be FROM or TO,
     // and somewhere earlier must be COPY (case-insensitive).
     const last = prevWords[prevWords.length - 1].toUpperCase();
-    if (last !== 'FROM' && last !== 'TO')
+    if (last !== "FROM" && last !== "TO")
         return false;
     for (let i = prevWords.length - 2; i >= 0; i--) {
-        if (prevWords[i].toUpperCase() === 'COPY')
+        if (prevWords[i].toUpperCase() === "COPY")
             return true;
         // If we walk past the start of statement (e.g. another keyword like
         // SELECT) we abort — only the SQL `COPY` form should match.
-        if (prevWords[i].toUpperCase() === 'SELECT' ||
-            prevWords[i].toUpperCase() === 'INSERT' ||
-            prevWords[i].toUpperCase() === 'UPDATE' ||
-            prevWords[i].toUpperCase() === 'DELETE' ||
-            prevWords[i].toUpperCase() === 'WITH') {
+        if (prevWords[i].toUpperCase() === "SELECT" ||
+            prevWords[i].toUpperCase() === "INSERT" ||
+            prevWords[i].toUpperCase() === "UPDATE" ||
+            prevWords[i].toUpperCase() === "DELETE" ||
+            prevWords[i].toUpperCase() === "WITH") {
             return false;
         }
     }

package/dist/psql/complete/index.js

@@ -20,8 +20,8 @@
  * the cursor was sitting on (`currentWord`), which we already compute in
  * `splitForCompletion` during tokenization.
  */
-import { splitForCompletion } from './matcher.js';
-import { findCompletions } from './rules.js';
+import { splitForCompletion } from "./matcher.js";
+import { findCompletions } from "./rules.js";
 /**
  * Build a completer bound to the given settings. The settings reference is
  * captured by closure; we never snapshot, so changes to `settings.db` (via
@@ -32,7 +32,7 @@ export const psqlCompleter = (ctx) => {
         const { prevWords, currentWord, replaceLength } = splitForCompletion(input, cursor);
         const ruleCtx = {
             settings: ctx.settings,
-            queryBuf: ctx.getQueryBuf?.() ?? '',
+            queryBuf: ctx.getQueryBuf?.() ?? "",
         };
         const { candidates } = await findCompletions(prevWords, currentWord, ruleCtx);
         // De-duplicate while preserving order.
@@ -97,7 +97,7 @@ const longestCommonPrefix = (candidates, fallback) => {
         out.push(first);
     }
     // Common prefix should not be shorter than what's already typed.
-    const candidatePrefix = out.join('');
+    const candidatePrefix = out.join("");
     if (candidatePrefix.length >= fallback.length)
         return candidatePrefix;
     return fallback;

package/dist/psql/complete/matcher.js

@@ -25,7 +25,7 @@
  * needs to do the same word-split-then-match dance.
  */
 export const MatchAny = null;
-export const MatchAnyExcept = (pattern) => '!' + pattern;
+export const MatchAnyExcept = (pattern) => "!" + pattern;
 const cimatch = (s1, s2, n, caseSensitive) => {
     if (s1.length < n || s2.length < n)
         return false;
@@ -43,7 +43,7 @@ const cimatch = (s1, s2, n, caseSensitive) => {
 export const wordMatches = (pattern, word, caseSensitive = false) => {
     if (pattern === null)
         return true;
-    if (pattern.startsWith('!')) {
+    if (pattern.startsWith("!")) {
         return !wordMatches(pattern.slice(1), word, caseSensitive);
     }
     const wordlen = word.length;
@@ -51,8 +51,8 @@ export const wordMatches = (pattern, word, caseSensitive = false) => {
     for (;;) {
         let starIdx = -1;
         let i = 0;
-        while (i < cursor.length && cursor[i] !== '|') {
-            if (cursor[i] === '*')
+        while (i < cursor.length && cursor[i] !== "|") {
+            if (cursor[i] === "*")
                 starIdx = i;
             i++;
         }
@@ -66,7 +66,8 @@ export const wordMatches = (pattern, word, caseSensitive = false) => {
             }
         }
         else {
-            if (wordlen === i && cimatch(word, cursor, wordlen, caseSensitive)) {
+            if (wordlen === i &&
+                cimatch(word, cursor, wordlen, caseSensitive)) {
                 return true;
             }
         }
@@ -147,12 +148,12 @@ export const tokenize = (input) => {
     while (i < input.length) {
         const ch = input[i];
         // Whitespace.
-        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
             i++;
             continue;
         }
         // Backslash command. Capture the entire backslash word as one token.
-        if (ch === '\\') {
+        if (ch === "\\") {
             const start = i;
             i++;
             // Single-char commands like `\!` and `\?` are valid; otherwise read
@@ -168,7 +169,7 @@ export const tokenize = (input) => {
                 // that key on `prevWords.length === 1` still fire. The
                 // `S` (system-objects) suffix is already a letter, so it's consumed
                 // above; only `+` needs explicit handling here.
-                while (i < input.length && input[i] === '+')
+                while (i < input.length && input[i] === "+")
                     i++;
             }
             out.push({
@@ -208,7 +209,7 @@ export const tokenize = (input) => {
             const start = i;
             i++;
             while (i < input.length) {
-                if (input[i] === '\\' && i + 1 < input.length) {
+                if (input[i] === "\\" && i + 1 < input.length) {
                     i += 2;
                     continue;
                 }
@@ -231,12 +232,12 @@ export const tokenize = (input) => {
             continue;
         }
         // Punctuation that splits words.
-        if (ch === ',' ||
-            ch === ';' ||
-            ch === '(' ||
-            ch === ')' ||
-            ch === '[' ||
-            ch === ']') {
+        if (ch === "," ||
+            ch === ";" ||
+            ch === "(" ||
+            ch === ")" ||
+            ch === "[" ||
+            ch === "]") {
             out.push({ text: ch, raw: ch, start: i, end: i + 1 });
             i++;
             continue;
@@ -246,19 +247,19 @@ export const tokenize = (input) => {
         const start = i;
         while (i < input.length) {
             const c = input[i];
-            if (c === ' ' ||
-                c === '\t' ||
-                c === '\n' ||
-                c === '\r' ||
-                c === ',' ||
-                c === ';' ||
-                c === '(' ||
-                c === ')' ||
-                c === '[' ||
-                c === ']' ||
+            if (c === " " ||
+                c === "\t" ||
+                c === "\n" ||
+                c === "\r" ||
+                c === "," ||
+                c === ";" ||
+                c === "(" ||
+                c === ")" ||
+                c === "[" ||
+                c === "]" ||
                 c === '"' ||
                 c === "'" ||
-                c === '\\') {
+                c === "\\") {
                 break;
             }
             i++;
@@ -289,16 +290,16 @@ export const splitForCompletion = (input, cursor) => {
     const head = input.slice(0, cursor);
     const tokens = tokenize(head);
     if (tokens.length === 0) {
-        return { prevWords: [], currentWord: '', replaceLength: 0 };
+        return { prevWords: [], currentWord: "", replaceLength: 0 };
     }
     const last = tokens[tokens.length - 1];
     // The cursor is sitting inside the last token if (a) it ends exactly at
     // cursor AND (b) the last char before cursor isn't whitespace.
     const charBefore = head[head.length - 1];
-    const inWhitespace = charBefore === ' ' ||
-        charBefore === '\t' ||
-        charBefore === '\n' ||
-        charBefore === '\r';
+    const inWhitespace = charBefore === " " ||
+        charBefore === "\t" ||
+        charBefore === "\n" ||
+        charBefore === "\r";
     if (last.end === head.length && !inWhitespace) {
         return {
             prevWords: tokens.slice(0, -1).map((t) => t.text),
@@ -308,7 +309,7 @@ export const splitForCompletion = (input, cursor) => {
     }
     return {
         prevWords: tokens.map((t) => t.text),
-        currentWord: '',
+        currentWord: "",
         replaceLength: 0,
     };
 };