neon 3.0.0 → 3.1.1

package/dist/psql/command/inputQueue.js

@@ -1,42 +1,44 @@
+//#region src/psql/command/inputQueue.ts
 /**
- * Pending-input queue for `\i` / `\include`.
- *
- * psql's `process_file()` switches the input source for the duration of an
- * included file: while a file is being processed, every subsequent input
- * line comes from the file, not the terminal. The natural place for that
- * switch is the mainloop (`MainLoop` in upstream `mainloop.c`).
- *
- * For WP-15 we keep `src/psql/core/mainloop.ts` untouched. Instead we expose
- * a tiny module-local queue. `\i` enqueues the contents of the included
- * file via {@link enqueue}; a future WP modifies the mainloop's line-source
- * to drain from {@link consumeNext} before reading more user input.
- *
- * Behaviour:
- *
- *  - The queue stores file contents as raw strings (typically containing
- *    multiple newline-separated SQL statements). Order is FIFO.
- *  - {@link consumeNext} returns the head, or `null` if the queue is empty.
- *  - {@link reset} clears the queue (used by tests and by any future error
- *    recovery path that wants to abandon pending input).
- *
- * The queue is module-scoped because it represents the include stack of a
- * single REPL. Tests should always call {@link reset} in their afterEach so
- * a leftover entry doesn't contaminate the next test.
- */
+* Pending-input queue for `\i` / `\include`.
+*
+* psql's `process_file()` switches the input source for the duration of an
+* included file: while a file is being processed, every subsequent input
+* line comes from the file, not the terminal. The natural place for that
+* switch is the mainloop (`MainLoop` in upstream `mainloop.c`).
+*
+* For WP-15 we keep `src/psql/core/mainloop.ts` untouched. Instead we expose
+* a tiny module-local queue. `\i` enqueues the contents of the included
+* file via {@link enqueue}; a future WP modifies the mainloop's line-source
+* to drain from {@link consumeNext} before reading more user input.
+*
+* Behaviour:
+*
+*  - The queue stores file contents as raw strings (typically containing
+*    multiple newline-separated SQL statements). Order is FIFO.
+*  - {@link consumeNext} returns the head, or `null` if the queue is empty.
+*  - {@link reset} clears the queue (used by tests and by any future error
+*    recovery path that wants to abandon pending input).
+*
+* The queue is module-scoped because it represents the include stack of a
+* single REPL. Tests should always call {@link reset} in their afterEach so
+* a leftover entry doesn't contaminate the next test.
+*/
 const pending = [];
 /** Append a string of input to the back of the queue. */
-export const enqueue = (content) => {
-    pending.push(content);
+const enqueue = (content) => {
+	pending.push(content);
 };
 /** Return and remove the next pending input, or `null` if none. */
-export const consumeNext = () => {
-    if (pending.length === 0)
-        return null;
-    return pending.shift() ?? null;
+const consumeNext = () => {
+	if (pending.length === 0) return null;
+	return pending.shift() ?? null;
 };
 /** Number of items currently in the queue. */
-export const size = () => pending.length;
+const size = () => pending.length;
 /** Empty the queue. Tests should call this in cleanup. */
-export const reset = () => {
-    pending.length = 0;
+const reset = () => {
+	pending.length = 0;
 };
+//#endregion
+export { consumeNext, enqueue, reset, size };

package/dist/psql/command/shared.js

@@ -1,71 +1,57 @@
+//#region src/psql/command/shared.ts
 /**
- * Internal helpers shared by `cmd_meta.ts` and `cmd_format.ts`.
- *
- * Kept deliberately tiny: just stream writes and the boolean coercion
- * shared by `\timing`, `\t`, `\x`, and `\pset` toggles. The implementations
- * mirror the relevant pieces of upstream `command.c` (`ParseVariableBool`)
- * and `print.c` / `print_aligned*` without depending on either.
- *
- * Why a shared file: the WP spec asks for cmd-isolated test factories, not
- * for the command implementations themselves to duplicate one-line
- * primitives. Going through these helpers also keeps the `noConsole`
- * lint rule satisfied — every write touches `process.stdout` /
- * `process.stderr` directly rather than `console.log` / `console.error`.
- */
+* Internal helpers shared by `cmd_meta.ts` and `cmd_format.ts`.
+*
+* Kept deliberately tiny: just stream writes and the boolean coercion
+* shared by `\timing`, `\t`, `\x`, and `\pset` toggles. The implementations
+* mirror the relevant pieces of upstream `command.c` (`ParseVariableBool`)
+* and `print.c` / `print_aligned*` without depending on either.
+*
+* Why a shared file: the WP spec asks for cmd-isolated test factories, not
+* for the command implementations themselves to duplicate one-line
+* primitives. Going through these helpers also keeps the `noConsole`
+* lint rule satisfied — every write touches `process.stdout` /
+* `process.stderr` directly rather than `console.log` / `console.error`.
+*/
 /** Write to stdout. */
-export const writeOut = (s) => {
-    process.stdout.write(s);
+const writeOut = (s) => {
+	process.stdout.write(s);
 };
 /** Write to stderr. */
-export const writeErr = (s) => {
-    process.stderr.write(s);
+const writeErr = (s) => {
+	process.stderr.write(s);
 };
 /**
- * Parse a psql boolean the way `ParseVariableBool` does — case-insensitive
- * unique-prefix match against `true|false|yes|no|on|off`, plus `1`/`0`.
- *
- * Returns `null` for unrecognised input.
- */
-export const parseBool = (raw) => {
-    if (raw.length === 0)
-        return null;
-    const lower = raw.toLowerCase();
-    const startsWith = (target) => lower.length <= target.length && target.startsWith(lower);
-    if (startsWith("true"))
-        return true;
-    if (startsWith("false"))
-        return false;
-    if (startsWith("yes"))
-        return true;
-    if (startsWith("no"))
-        return false;
-    if (lower.length >= 2) {
-        if ("on".startsWith(lower))
-            return true;
-        if ("off".startsWith(lower))
-            return false;
-    }
-    if (raw === "1")
-        return true;
-    if (raw === "0")
-        return false;
-    return null;
+* Parse a psql boolean the way `ParseVariableBool` does — case-insensitive
+* unique-prefix match against `true|false|yes|no|on|off`, plus `1`/`0`.
+*
+* Returns `null` for unrecognised input.
+*/
+const parseBool = (raw) => {
+	if (raw.length === 0) return null;
+	const lower = raw.toLowerCase();
+	const startsWith = (target) => lower.length <= target.length && target.startsWith(lower);
+	if (startsWith("true")) return true;
+	if (startsWith("false")) return false;
+	if (startsWith("yes")) return true;
+	if (startsWith("no")) return false;
+	if (lower.length >= 2) {
+		if ("on".startsWith(lower)) return true;
+		if ("off".startsWith(lower)) return false;
+	}
+	if (raw === "1") return true;
+	if (raw === "0") return false;
+	return null;
 };
-export const parseTriple = (raw) => {
-    const lower = raw.toLowerCase();
-    if (lower.length === 0)
-        return null;
-    // Resolve booleans FIRST. Otherwise `t` matched the `toggle` prefix before
-    // parseBool, so `\x t` toggled rather than turning expanded ON, and `\pset`
-    // bool prefixes were inverted (review: minor divergences).
-    const b = parseBool(raw);
-    if (b === true)
-        return "on";
-    if (b === false)
-        return "off";
-    if ("auto".startsWith(lower))
-        return "auto";
-    if ("toggle".startsWith(lower))
-        return "toggle";
-    return null;
+const parseTriple = (raw) => {
+	const lower = raw.toLowerCase();
+	if (lower.length === 0) return null;
+	const b = parseBool(raw);
+	if (b === true) return "on";
+	if (b === false) return "off";
+	if ("auto".startsWith(lower)) return "auto";
+	if ("toggle".startsWith(lower)) return "toggle";
+	return null;
 };
+//#endregion
+export { parseBool, parseTriple, writeErr, writeOut };

package/dist/psql/complete/filenames.js

@@ -1,139 +1,96 @@
-/**
- * Filesystem-driven completion candidates for `\lo_*`, `\copy ... FROM/TO`,
- * and SQL `COPY ... FROM/TO`.
- *
- * Upstream psql implements this via readline's `rl_filename_completion_function`
- * plus a couple of custom `complete_from_files*` wrappers. We don't have
- * readline; we re-implement the bits we need with `fs.readdirSync`.
- *
- * The completer enumerates entries in the directory referenced by the
- * partial input, filters by basename prefix, and returns *full* candidates
- * (path + basename, matching what the user typed). Directories get a
- * trailing `/` so the editor's `shouldAppendSpace` keeps the user typing
- * through them.
- *
- * For the SQL `COPY ... FROM/TO` context — where the filename must be a
- * string literal — the candidates are wrapped in single quotes. Closing
- * quotes are added only when the candidate is a final filename (unique
- * match), so the line editor's "balanced quotes → append space" rule
- * fires; partial multi-candidate prefixes leave the closing quote off so
- * the user can keep typing.
- */
 import { readdirSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+//#region src/psql/complete/filenames.ts
+/**
+* Filesystem-driven completion candidates for `\lo_*`, `\copy ... FROM/TO`,
+* and SQL `COPY ... FROM/TO`.
+*
+* Upstream psql implements this via readline's `rl_filename_completion_function`
+* plus a couple of custom `complete_from_files*` wrappers. We don't have
+* readline; we re-implement the bits we need with `fs.readdirSync`.
+*
+* The completer enumerates entries in the directory referenced by the
+* partial input, filters by basename prefix, and returns *full* candidates
+* (path + basename, matching what the user typed). Directories get a
+* trailing `/` so the editor's `shouldAppendSpace` keeps the user typing
+* through them.
+*
+* For the SQL `COPY ... FROM/TO` context — where the filename must be a
+* string literal — the candidates are wrapped in single quotes. Closing
+* quotes are added only when the candidate is a final filename (unique
+* match), so the line editor's "balanced quotes → append space" rule
+* fires; partial multi-candidate prefixes leave the closing quote off so
+* the user can keep typing.
+*/
 /**
- * Enumerate filesystem entries matching the partial path the user typed.
- *
- * `currentWord` is the raw token (post-tokenizer). It may contain a leading
- * `'` (when the user is already inside a single-quoted SQL literal). The
- * function strips that, looks up the dirname/basename, and returns full
- * candidates that the line editor can splice in with `replaceLength = code
- * points in currentWord`.
- *
- * Returns an empty array on any filesystem error (e.g. directory doesn't
- * exist, no read permission). Tab completion is best-effort — failing to
- * complete is the same as "no candidates".
- */
-export const completeFilenames = (currentWord, quoteCtx, cwd = process.cwd()) => {
-    // Strip an opening single quote (the SQL string-literal case) before
-    // resolving the path. The tokenizer keeps it as part of the word.
-    let raw = currentWord;
-    let hadOpeningSingleQuote = false;
-    if (raw.startsWith("'")) {
-        hadOpeningSingleQuote = true;
-        raw = raw.slice(1);
-    }
-    // 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 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 === ""
-        ? cwd
-        : dirPart.startsWith("/")
-            ? dirPart
-            : join(cwd, dirPart);
-    let entries;
-    try {
-        entries = readdirSync(scanDir);
-    }
-    catch {
-        return [];
-    }
-    // Filter by prefix. Filesystem matching is case-sensitive on Linux/macOS
-    // (case-insensitive on macOS by default, but we mirror upstream readline's
-    // behaviour which honours the OS's path semantics — case-sensitive on
-    // POSIX, which is what the conformance suite runs on).
-    const filtered = entries.filter((e) => e.startsWith(basePrefix));
-    // Sort alphabetically so the listing is predictable.
-    filtered.sort();
-    // Build the candidates. Each is `dirPart + entry` (full path matching
-    // what the user typed) plus optional trailing `/` for directories.
-    const candidates = [];
-    for (const entry of filtered) {
-        let isDir = false;
-        try {
-            isDir = statSync(join(scanDir, entry)).isDirectory();
-        }
-        catch {
-            // Broken symlink etc. — treat as regular file.
-        }
-        const full = dirPart + entry + (isDir ? "/" : "");
-        candidates.push(full);
-    }
-    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) {
-            return candidates.map((c) => "'" + c);
-        }
-        return candidates;
-    }
-    // SQL string-literal context: wrap candidates in single quotes. The
-    // 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("/")) {
-        // 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] + "'"];
-    }
-    // Multiple candidates OR directory match: opening quote only; closing
-    // quote is deferred so the user keeps typing.
-    return candidates.map((c) => "'" + c);
+* Enumerate filesystem entries matching the partial path the user typed.
+*
+* `currentWord` is the raw token (post-tokenizer). It may contain a leading
+* `'` (when the user is already inside a single-quoted SQL literal). The
+* function strips that, looks up the dirname/basename, and returns full
+* candidates that the line editor can splice in with `replaceLength = code
+* points in currentWord`.
+*
+* Returns an empty array on any filesystem error (e.g. directory doesn't
+* exist, no read permission). Tab completion is best-effort — failing to
+* complete is the same as "no candidates".
+*/
+const completeFilenames = (currentWord, quoteCtx, cwd = process.cwd()) => {
+	let raw = currentWord;
+	let hadOpeningSingleQuote = false;
+	if (raw.startsWith("'")) {
+		hadOpeningSingleQuote = true;
+		raw = raw.slice(1);
+	}
+	const lastSlash = raw.lastIndexOf("/");
+	const dirPart = lastSlash === -1 ? "" : raw.slice(0, lastSlash + 1);
+	const basePrefix = lastSlash === -1 ? raw : raw.slice(lastSlash + 1);
+	const scanDir = dirPart === "" ? cwd : dirPart.startsWith("/") ? dirPart : join(cwd, dirPart);
+	let entries;
+	try {
+		entries = readdirSync(scanDir);
+	} catch {
+		return [];
+	}
+	const filtered = entries.filter((e) => e.startsWith(basePrefix));
+	filtered.sort();
+	const candidates = [];
+	for (const entry of filtered) {
+		let isDir = false;
+		try {
+			isDir = statSync(join(scanDir, entry)).isDirectory();
+		} catch {}
+		const full = dirPart + entry + (isDir ? "/" : "");
+		candidates.push(full);
+	}
+	if (quoteCtx === "none") {
+		if (hadOpeningSingleQuote) return candidates.map((c) => "'" + c);
+		return candidates;
+	}
+	if (candidates.length === 1 && !candidates[0].endsWith("/")) return ["'" + candidates[0] + "'"];
+	return candidates.map((c) => "'" + c);
 };
 /**
- * Helper used by `rules.ts` to decide whether the SQL `COPY` we're
- * completing for is a `FROM` (input file) or `TO` (output file). Returns
- * `true` for either — both want filename completion.
- *
- * `prevWords` here is the full prev-words token list. We look for the
- * pattern `COPY <table>+ [FROM|TO]` anywhere as a tail match.
- */
-export const isCopyFromOrTo = (prevWords) => {
-    if (prevWords.length < 3)
-        return false;
-    // 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")
-        return false;
-    for (let i = prevWords.length - 2; i >= 0; i--) {
-        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") {
-            return false;
-        }
-    }
-    return false;
+* Helper used by `rules.ts` to decide whether the SQL `COPY` we're
+* completing for is a `FROM` (input file) or `TO` (output file). Returns
+* `true` for either — both want filename completion.
+*
+* `prevWords` here is the full prev-words token list. We look for the
+* pattern `COPY <table>+ [FROM|TO]` anywhere as a tail match.
+*/
+const isCopyFromOrTo = (prevWords) => {
+	if (prevWords.length < 3) return false;
+	const last = prevWords[prevWords.length - 1].toUpperCase();
+	if (last !== "FROM" && last !== "TO") return false;
+	for (let i = prevWords.length - 2; i >= 0; i--) {
+		if (prevWords[i].toUpperCase() === "COPY") return true;
+		if (prevWords[i].toUpperCase() === "SELECT" || prevWords[i].toUpperCase() === "INSERT" || prevWords[i].toUpperCase() === "UPDATE" || prevWords[i].toUpperCase() === "DELETE" || prevWords[i].toUpperCase() === "WITH") return false;
+	}
+	return false;
+};
+const _internals = {
+	basename,
+	dirname
 };
-// Re-export for tests.
-export const _internals = { basename, dirname };
+//#endregion
+export { _internals, completeFilenames, isCopyFromOrTo };

package/dist/psql/complete/index.js

@@ -1,104 +1,66 @@
-/**
- * Public entrypoint for psql tab completion.
- *
- * The `LineEditor` (WP-24) accepts a `Completer` of shape
- * `(input, cursor) => Promise<CompletionResult>`. We return a CURRIED
- * factory `psqlCompleter(ctx)` that captures the settings reference so the
- * completer can read `ctx.settings.db` lazily on every call — important
- * because `\c` swaps out the live connection.
- *
- * `CompletionResult` (defined in lineEditor/complete.ts):
- *
- *   - candidates:    string[]   the list shown / inserted
- *   - commonPrefix:  string     longest prefix the editor can insert without
- *                               making a choice (`apply` walks this)
- *   - replaceLength: number     code-points to chop off the buffer before
- *                               inserting `candidates[i]` / commonPrefix
- *
- * Our `findCompletions` returns raw candidate strings; we compute the common
- * prefix here. `replaceLength` is the code-point length of the partial word
- * the cursor was sitting on (`currentWord`), which we already compute in
- * `splitForCompletion` during tokenization.
- */
 import { splitForCompletion } from "./matcher.js";
 import { findCompletions } from "./rules.js";
+//#region src/psql/complete/index.ts
 /**
- * Build a completer bound to the given settings. The settings reference is
- * captured by closure; we never snapshot, so changes to `settings.db` (via
- * `\c`) take effect immediately.
- */
-export const psqlCompleter = (ctx) => {
-    const completer = async (input, cursor) => {
-        const { prevWords, currentWord, replaceLength } = splitForCompletion(input, cursor);
-        const ruleCtx = {
-            settings: ctx.settings,
-            queryBuf: ctx.getQueryBuf?.() ?? "",
-        };
-        const { candidates } = await findCompletions(prevWords, currentWord, ruleCtx);
-        // De-duplicate while preserving order.
-        const seen = new Set();
-        const deduped = [];
-        for (const c of candidates) {
-            if (!seen.has(c)) {
-                seen.add(c);
-                deduped.push(c);
-            }
-        }
-        // Stable sort so the listing is predictable. The first-character sort
-        // key uses lowercase so case-mixed candidate lists don't look chaotic.
-        deduped.sort((a, b) => {
-            const la = a.toLowerCase();
-            const lb = b.toLowerCase();
-            if (la < lb)
-                return -1;
-            if (la > lb)
-                return 1;
-            return 0;
-        });
-        const commonPrefix = longestCommonPrefix(deduped, currentWord);
-        return {
-            candidates: deduped,
-            commonPrefix,
-            replaceLength,
-        };
-    };
-    return completer;
+* Build a completer bound to the given settings. The settings reference is
+* captured by closure; we never snapshot, so changes to `settings.db` (via
+* `\c`) take effect immediately.
+*/
+const psqlCompleter = (ctx) => {
+	const completer = async (input, cursor) => {
+		const { prevWords, currentWord, replaceLength } = splitForCompletion(input, cursor);
+		const ruleCtx = {
+			settings: ctx.settings,
+			queryBuf: ctx.getQueryBuf?.() ?? ""
+		};
+		const { candidates } = await findCompletions(prevWords, currentWord, ruleCtx);
+		const seen = /* @__PURE__ */ new Set();
+		const deduped = [];
+		for (const c of candidates) if (!seen.has(c)) {
+			seen.add(c);
+			deduped.push(c);
+		}
+		deduped.sort((a, b) => {
+			const la = a.toLowerCase();
+			const lb = b.toLowerCase();
+			if (la < lb) return -1;
+			if (la > lb) return 1;
+			return 0;
+		});
+		return {
+			candidates: deduped,
+			commonPrefix: longestCommonPrefix(deduped, currentWord),
+			replaceLength
+		};
+	};
+	return completer;
 };
-// ---------------------------------------------------------------------------
-// Helpers.
-// ---------------------------------------------------------------------------
 /**
- * Return the longest common prefix of all candidates, but never shorter
- * than the user's partial input (so we don't backtrack the buffer when the
- * completion is a no-op).
- *
- * If there's a single candidate, returns it whole.
- */
+* Return the longest common prefix of all candidates, but never shorter
+* than the user's partial input (so we don't backtrack the buffer when the
+* completion is a no-op).
+*
+* If there's a single candidate, returns it whole.
+*/
 const longestCommonPrefix = (candidates, fallback) => {
-    if (candidates.length === 0)
-        return fallback;
-    if (candidates.length === 1)
-        return candidates[0];
-    // Use code-point iteration so multi-byte characters don't get cut.
-    const arrs = candidates.map((c) => Array.from(c));
-    const minLen = arrs.reduce((m, a) => Math.min(m, a.length), Infinity);
-    const out = [];
-    for (let i = 0; i < minLen; i++) {
-        const first = arrs[0][i];
-        let ok = true;
-        for (let j = 1; j < arrs.length; j++) {
-            if (arrs[j][i] !== first) {
-                ok = false;
-                break;
-            }
-        }
-        if (!ok)
-            break;
-        out.push(first);
-    }
-    // Common prefix should not be shorter than what's already typed.
-    const candidatePrefix = out.join("");
-    if (candidatePrefix.length >= fallback.length)
-        return candidatePrefix;
-    return fallback;
+	if (candidates.length === 0) return fallback;
+	if (candidates.length === 1) return candidates[0];
+	const arrs = candidates.map((c) => Array.from(c));
+	const minLen = arrs.reduce((m, a) => Math.min(m, a.length), Infinity);
+	const out = [];
+	for (let i = 0; i < minLen; i++) {
+		const first = arrs[0][i];
+		let ok = true;
+		for (let j = 1; j < arrs.length; j++) if (arrs[j][i] !== first) {
+			ok = false;
+			break;
+		}
+		if (!ok) break;
+		out.push(first);
+	}
+	const candidatePrefix = out.join("");
+	if (candidatePrefix.length >= fallback.length) return candidatePrefix;
+	return fallback;
 };
+//#endregion
+export { psqlCompleter };