neonctl 2.37.0 → 2.38.0

package/dist/psql/command/cmd_show.js

@@ -1,766 +0,0 @@
-/**
- * `\sf [+] FUNCNAME` / `\sv [+] VIEWNAME` show-source commands and their
- * `\ef` / `\ev` edit-form siblings, ported from upstream `command.c`'s
- * `exec_command_sf_sv` and `exec_command_ef_ev`.
- *
- * Behaviour matches upstream byte-for-byte for the show forms:
- *
- *   1. Lookup the object's OID — function via `regproc` (or `regprocedure`
- *      when the name carries an argument list `(int)`), view via `regclass`.
- *   2. Fetch the definition — `pg_get_functiondef(oid)` for functions; for
- *      views we re-assemble the `CREATE OR REPLACE VIEW … AS …` head (with
- *      schema-qualified name, reloptions, and optional `WITH CHECK OPTION`)
- *      around the body returned by `pg_get_viewdef(oid, true)`.
- *   3. Stream the rendered text to `stdout`, optionally prefixed by line
- *      numbers when the user passed `+` (e.g. `\sf+ foo`).
- *
- * Line-number formatting (mirrors upstream `print_with_linenumbers`):
- *
- *   - For functions: lines before the body marker (`AS `, `BEGIN `, or
- *     `RETURN `) are unnumbered and rendered as `        <line>\n` (8 spaces
- *     of padding). Body lines render as `<lineno>      <line>\n` where the
- *     numeric field is left-justified in a 7-character slot, with one
- *     literal space separator. The first body line becomes line 1.
- *   - For views: every line is a "body" line — `lineno` starts at 1 and
- *     increments for every output line, no header padding.
- *
- * Edit forms (`\ef` / `\ev`):
- *   We do not implement editor invocation — that needs TTY interaction and
- *   `$EDITOR` semantics outside the scope of this embedded psql. When the
- *   user supplies a name we route through the same fetch+print path as the
- *   show forms (`\ef foo` ≡ `\sf foo`); without a name we error with a hint
- *   pointing back at `\sf` / `\sv`.
- *
- * Argument parsing matches upstream's `OT_WHOLE_LINE`: we slurp the rest of
- * the line and trim, so `\sf  myschema.foo  ` round-trips cleanly without
- * splitting on the dot or whitespace inside parens.
- */
-import { writeErr, writeOut } from "./shared.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Emit a `\<cmd>: <message>` error to stderr, stash the message on
- * `lastErrorResult` so `\errverbose` / the mainloop fallback see it, and
- * return an error result with `errorWritten: true` so the mainloop doesn't
- * double-print.
- */
-const errResult = (ctx, message) => {
-    ctx.settings.lastErrorResult = { message };
-    writeErr(`\\${ctx.cmdName}: ${message}\n`);
-    return { status: "error", errorWritten: true };
-};
-/**
- * Format a server error for stderr the way upstream's
- * `minimal_error_message` does: `<severity>:  <primary message>\n`. Falls
- * back to "ERROR:" + Error.message when the error doesn't carry severity /
- * message fields (e.g. a wire-layer rejection).
- */
-const formatServerError = (err) => {
-    if (err && typeof err === "object") {
-        const e = err;
-        const sev = e.severity ?? "ERROR";
-        const msg = e.message ??
-            (err instanceof Error ? err.message : safeToString(err));
-        return `${sev}:  ${msg}`;
-    }
-    if (err instanceof Error)
-        return `ERROR:  ${err.message}`;
-    return `ERROR:  ${safeToString(err)}`;
-};
-/**
- * Coerce an unknown value to a string defensively. Plain non-`Error`
- * objects would render as `[object Object]` via the default `String()`
- * path; we sidestep that by JSON-encoding when possible (falls back to
- * the typeof when JSON throws — e.g. circular structures).
- */
-const safeToString = (v) => {
-    if (v === null)
-        return "null";
-    if (v === undefined)
-        return "undefined";
-    if (typeof v === "string")
-        return v;
-    if (typeof v === "number" ||
-        typeof v === "boolean" ||
-        typeof v === "bigint") {
-        return String(v);
-    }
-    try {
-        return JSON.stringify(v) ?? typeof v;
-    }
-    catch {
-        return typeof v;
-    }
-};
-/**
- * Print a server-side query failure the way upstream does — `<sev>:  <msg>`
- * directly on stderr, without the `\<cmd>: ` prefix that local-only errors
- * use. Also stashes the message on `lastErrorResult` so `\errverbose`
- * survives.
- */
-const queryErrResult = (ctx, err) => {
-    const line = formatServerError(err);
-    ctx.settings.lastErrorResult = {
-        message: err &&
-            typeof err === "object" &&
-            err.message
-            ? err.message
-            : err instanceof Error
-                ? err.message
-                : safeToString(err),
-    };
-    writeErr(`${line}\n`);
-    return { status: "error", errorWritten: true };
-};
-const conn = (ctx) => ctx.settings.db;
-const noConn = (ctx) => errResult(ctx, "no connection to the server");
-/**
- * Read the object descriptor as a whole-line argument with surrounding
- * whitespace AND trailing semicolons stripped. Returns `null` when no
- * name was supplied (after the strip — i.e. `\sf   ` or `\sf  ;;` is
- * treated as empty).
- *
- * Upstream `psql_scan_slash_option(scan_state, OT_WHOLE_LINE, …)` keeps
- * the `;` in the returned string, but `exec_command_sf_sv` (and its `ef`/
- * `ev` siblings) trim trailing whitespace + `;` before passing the
- * descriptor to `lookup_object_oid`. Without this, `\sf ts_debug(text);`
- * sends `'ts_debug(text);'::regprocedure` to the server, which the
- * regprocedure input parser rejects with "expected a right parenthesis".
- */
-const readObjDesc = (ctx) => {
-    const raw = ctx.restOfLine();
-    // Strip trailing whitespace and `;` (in any order, any count) so
-    // `\sf foo(arg) ;; ` round-trips like vanilla psql.
-    const trimmed = raw.replace(/[\s;]+$/, "").trimStart();
-    return trimmed.length === 0 ? null : trimmed;
-};
-/**
- * Decode whether the command name ends in `+` (request line numbers). The
- * caller knows the base name (`sf`, `sv`, `ef`, `ev`); any extra letters
- * are looked at for a literal `+`.
- */
-const decodeShowSuffix = (cmdName, base) => {
-    const tail = cmdName.slice(base.length);
-    return { plus: tail.includes("+") };
-};
-/**
- * Look up a function OID from `desc`. Mirrors upstream's
- * `lookup_object_oid(EditableFunction, ...)` exactly:
- *
- *   - If `desc` contains `(`, cast through `regprocedure` (which resolves
- *     by full argument signature, e.g. `foo(int)`).
- *   - Otherwise cast through `regproc` (which matches by bare name and
- *     errors on overloaded ambiguity).
- *
- * The descriptor is passed as a SQL string literal — we use the server's
- * `escapeLiteral` to mirror libpq's `appendStringLiteralConn`.
- */
-const lookupFunctionOid = async (c, desc) => {
-    const cast = desc.includes("(") ? "regprocedure" : "regproc";
-    const sql = `SELECT ${c.escapeLiteral(desc)}::pg_catalog.${cast}::pg_catalog.oid`;
-    try {
-        const rs = await c.query(sql, []);
-        if (rs.rows.length !== 1 || rs.rows[0][0] === null) {
-            return {
-                ok: false,
-                err: new Error("object lookup returned no rows"),
-            };
-        }
-        const raw = cellToString(rs.rows[0][0]);
-        const oid = Number(raw);
-        if (!Number.isFinite(oid)) {
-            return {
-                ok: false,
-                err: new Error(`invalid oid in lookup result: ${raw}`),
-            };
-        }
-        return { ok: true, oid };
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
-};
-/**
- * Look up a view OID from `desc` via `regclass`. Matches upstream's
- * `lookup_object_oid(EditableView, ...)`. Note that this does NOT verify
- * the relation is actually a view; the kind check happens in
- * `getViewCreateCmd` where upstream catches it via the relkind column.
- */
-const lookupRelationOid = async (c, desc) => {
-    const sql = `SELECT ${c.escapeLiteral(desc)}::pg_catalog.regclass::pg_catalog.oid`;
-    try {
-        const rs = await c.query(sql, []);
-        if (rs.rows.length !== 1 || rs.rows[0][0] === null) {
-            return {
-                ok: false,
-                err: new Error("object lookup returned no rows"),
-            };
-        }
-        const raw = cellToString(rs.rows[0][0]);
-        const oid = Number(raw);
-        if (!Number.isFinite(oid)) {
-            return {
-                ok: false,
-                err: new Error(`invalid oid in lookup result: ${raw}`),
-            };
-        }
-        return { ok: true, oid };
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
-};
-/**
- * Coerce a wire-layer cell to a string. Text-mode results arrive as
- * strings; null is treated as "" so missing-row paths fall through to
- * empty output instead of crashing.
- */
-const cellToString = (v) => {
-    if (v === null || v === undefined)
-        return "";
-    if (typeof v === "string")
-        return v;
-    if (Buffer.isBuffer(v))
-        return v.toString("utf-8");
-    if (typeof v === "number" ||
-        typeof v === "boolean" ||
-        typeof v === "bigint") {
-        return String(v);
-    }
-    // Non-primitive fallback: encode JSON so we never emit a stray
-    // `[object Object]`. The wire layer hands us strings or nulls in
-    // practice, so this branch is defensive only.
-    try {
-        return JSON.stringify(v) ?? "";
-    }
-    catch {
-        return "";
-    }
-};
-/**
- * Fetch the CREATE FUNCTION source for `oid` via
- * `pg_catalog.pg_get_functiondef(oid)`. Upstream guarantees the result is
- * newline-terminated; we re-assert that here so the caller can stream
- * straight to stdout (or hand to the line-number formatter).
- */
-const getFunctionCreateCmd = async (c, oid) => {
-    const sql = `SELECT pg_catalog.pg_get_functiondef(${oid})`;
-    try {
-        const rs = await c.query(sql, []);
-        if (rs.rows.length !== 1) {
-            return {
-                ok: false,
-                err: new Error("function definition not found"),
-            };
-        }
-        let def = cellToString(rs.rows[0][0]);
-        if (def.length > 0 && !def.endsWith("\n"))
-            def += "\n";
-        return { ok: true, def };
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
-};
-/**
- * Quote an SQL identifier when needed. Mirrors libpq's `fmtId`: lowercase
- * ASCII identifiers starting with `[a-z_]` and continuing with
- * `[a-z0-9_$]` may go unquoted; anything else gets double-quoted with
- * embedded double-quotes doubled. Used to schema-qualify view names in
- * the synthesised `CREATE OR REPLACE VIEW …` head.
- */
-const fmtId = (ident) => {
-    if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !RESERVED_WORDS.has(ident)) {
-        return ident;
-    }
-    return `"${ident.replace(/"/g, '""')}"`;
-};
-/**
- * Minimal reserved-word set used by `fmtId`. Upstream's `fmtId` is much
- * more conservative — any keyword needs quoting regardless of category.
- * For our use case we only quote the keywords that show up as actual
- * relation names; that's vanishingly rare in practice (CREATE VIEW
- * "select" AS … is legal but no one does it). Keeping the set small
- * avoids a large keyword table; the worst case is an un-needed
- * double-quote pair, which is still valid SQL.
- */
-const RESERVED_WORDS = new Set([
-    "all",
-    "analyse",
-    "analyze",
-    "and",
-    "any",
-    "array",
-    "as",
-    "asc",
-    "asymmetric",
-    "both",
-    "case",
-    "cast",
-    "check",
-    "collate",
-    "column",
-    "constraint",
-    "create",
-    "current_catalog",
-    "current_date",
-    "current_role",
-    "current_time",
-    "current_timestamp",
-    "current_user",
-    "default",
-    "deferrable",
-    "desc",
-    "distinct",
-    "do",
-    "else",
-    "end",
-    "except",
-    "false",
-    "fetch",
-    "for",
-    "foreign",
-    "from",
-    "grant",
-    "group",
-    "having",
-    "in",
-    "initially",
-    "intersect",
-    "into",
-    "lateral",
-    "leading",
-    "limit",
-    "localtime",
-    "localtimestamp",
-    "not",
-    "null",
-    "offset",
-    "on",
-    "only",
-    "or",
-    "order",
-    "placing",
-    "primary",
-    "references",
-    "returning",
-    "select",
-    "session_user",
-    "some",
-    "symmetric",
-    "table",
-    "then",
-    "to",
-    "trailing",
-    "true",
-    "union",
-    "unique",
-    "user",
-    "using",
-    "variadic",
-    "when",
-    "where",
-    "window",
-    "with",
-]);
-/**
- * Re-build a `CREATE OR REPLACE VIEW <schema>.<name>[ WITH (opts)] AS
- * <body>[\n WITH <checkoption> CHECK OPTION]\n` definition the same way
- * upstream's `get_create_object_cmd(EditableView)` does. Returns either
- * the assembled text or a synthetic error when the relation isn't
- * actually a view.
- */
-const getViewCreateCmd = async (c, oid) => {
-    const ver = c.serverVersion >= 90400 ? "modern" : "legacy";
-    const sql = ver === "modern"
-        ? `SELECT nspname, relname, relkind, ` +
-            `pg_catalog.pg_get_viewdef(c.oid, true), ` +
-            `pg_catalog.array_remove(pg_catalog.array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, ` +
-            `CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text ` +
-            `WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption ` +
-            `FROM pg_catalog.pg_class c ` +
-            `LEFT JOIN pg_catalog.pg_namespace n ` +
-            `ON c.relnamespace = n.oid WHERE c.oid = ${oid}`
-        : `SELECT nspname, relname, relkind, ` +
-            `pg_catalog.pg_get_viewdef(c.oid, true), ` +
-            `c.reloptions AS reloptions, ` +
-            `NULL AS checkoption ` +
-            `FROM pg_catalog.pg_class c ` +
-            `LEFT JOIN pg_catalog.pg_namespace n ` +
-            `ON c.relnamespace = n.oid WHERE c.oid = ${oid}`;
-    let rs;
-    try {
-        rs = await c.query(sql, []);
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
-    if (rs.rows.length !== 1) {
-        return { ok: false, err: new Error("view definition not found") };
-    }
-    const row = rs.rows[0];
-    const nspname = cellToString(row[0]);
-    const relname = cellToString(row[1]);
-    const relkind = cellToString(row[2]);
-    const viewdef = cellToString(row[3]);
-    const reloptions = row[4]; // may be string ("{a=b,c=d}") or null
-    const checkoption = cellToString(row[5]);
-    if (relkind !== "v") {
-        return {
-            ok: false,
-            err: new Error(`"${nspname}.${relname}" is not a view`),
-        };
-    }
-    let out = "CREATE OR REPLACE VIEW ";
-    out += `${fmtId(nspname)}.${fmtId(relname)}`;
-    // reloptions: postgres returns it as a text-mode array literal like
-    // `{foo=bar,baz=qux}`; we only need to detect non-empty (different
-    // from the literal `{}`) and split entries on `,` outside quotes.
-    const reloptStr = reloptions === null ? null : cellToString(reloptions);
-    if (reloptStr !== null && reloptStr.length > 2) {
-        out += "\n WITH (";
-        out += renderReloptions(reloptStr);
-        out += ")";
-    }
-    out += ` AS\n${viewdef}`;
-    // Strip trailing semicolon from pg_get_viewdef.
-    if (out.endsWith(";")) {
-        out = out.slice(0, -1);
-    }
-    if (checkoption !== "") {
-        out += `\n WITH ${checkoption} CHECK OPTION`;
-    }
-    if (!out.endsWith("\n"))
-        out += "\n";
-    return { ok: true, def: out };
-};
-/**
- * Render a Postgres text-mode array literal of `key=value` reloption
- * entries (e.g. `{security_barrier=true,security_invoker=false}`) into
- * the comma-separated `key=value, key2=value2` form upstream emits
- * inside the `WITH (…)` clause.
- *
- * Mirrors `appendReloptionsArray`'s output behaviour for the limited
- * surface relevant to views (no per-namespace options, no embedded
- * quotes). For any value that contains characters that would need
- * escaping in SQL — anything other than `[A-Za-z0-9_.\-]` — we render
- * it as a quoted string literal, matching upstream's `appendStringLiteral`
- * fallback.
- */
-const renderReloptions = (literal) => {
-    // Strip surrounding `{}`.
-    if (!literal.startsWith("{") || !literal.endsWith("}")) {
-        return literal;
-    }
-    const inside = literal.slice(1, -1);
-    if (inside.length === 0)
-        return "";
-    // Postgres array literals quote individual elements with `"…"` when
-    // they contain commas or special chars. For reloptions on a view the
-    // values are typically bare `key=value` strings, but we still need to
-    // tolerate the quoted form.
-    const entries = splitArrayElems(inside);
-    const out = [];
-    for (let entry of entries) {
-        // unquote double-quoted entries
-        if (entry.startsWith('"') && entry.endsWith('"')) {
-            entry = entry
-                .slice(1, -1)
-                .replace(/\\"/g, '"')
-                .replace(/\\\\/g, "\\");
-        }
-        const eq = entry.indexOf("=");
-        if (eq < 0) {
-            out.push(entry);
-            continue;
-        }
-        const key = entry.slice(0, eq);
-        const value = entry.slice(eq + 1);
-        if (/^[A-Za-z0-9_.-]+$/.test(value)) {
-            out.push(`${key}=${value}`);
-        }
-        else {
-            // Quote the value as a SQL string literal.
-            out.push(`${key}='${value.replace(/'/g, "''")}'`);
-        }
-    }
-    return out.join(", ");
-};
-/** Split a Postgres text-mode array's inner content on top-level commas. */
-const splitArrayElems = (s) => {
-    const out = [];
-    let i = 0;
-    let cur = "";
-    let inQuote = false;
-    while (i < s.length) {
-        const ch = s[i];
-        if (ch === "\\" && i + 1 < s.length) {
-            cur += s[i] + s[i + 1];
-            i += 2;
-            continue;
-        }
-        if (ch === '"') {
-            inQuote = !inQuote;
-            cur += ch;
-            i++;
-            continue;
-        }
-        if (ch === "," && !inQuote) {
-            out.push(cur);
-            cur = "";
-            i++;
-            continue;
-        }
-        cur += ch;
-        i++;
-    }
-    if (cur.length > 0 || s.endsWith(","))
-        out.push(cur);
-    return out;
-};
-/**
- * Print `buf` with line numbers in the upstream format:
- *
- *   - For functions (`isFunc=true`): scan for the first line whose first
- *     three / six / seven bytes are `AS `, `BEGIN `, or `RETURN ` and
- *     treat that as the start of the body. Header lines (before the
- *     marker) render as `        <line>\n`; body lines render as
- *     `<lineno><6 spaces> <line>\n` (`%-7d %s\n`), with `lineno` starting
- *     at 1 on the marker line.
- *   - For views (`isFunc=false`): everything is body; `lineno` starts at
- *     1 and increments per output line.
- */
-const writeWithLineNumbers = (buf, isFunc, out) => {
-    let inHeader = isFunc;
-    let lineno = 0;
-    let i = 0;
-    while (i < buf.length) {
-        // Find end-of-line.
-        const eol = buf.indexOf("\n", i);
-        const line = eol === -1 ? buf.slice(i) : buf.slice(i, eol);
-        if (inHeader &&
-            (line.startsWith("AS ") ||
-                line.startsWith("BEGIN ") ||
-                line.startsWith("RETURN "))) {
-            inHeader = false;
-        }
-        if (!inHeader)
-            lineno++;
-        if (inHeader) {
-            out(`        ${line}\n`);
-        }
-        else {
-            // %-7d → left-justified, padded to 7. Then literal space, then line.
-            const numStr = String(lineno);
-            const pad = numStr.length >= 7 ? "" : " ".repeat(7 - numStr.length);
-            out(`${numStr}${pad} ${line}\n`);
-        }
-        if (eol === -1)
-            break;
-        i = eol + 1;
-    }
-};
-/** Stream the definition (with or without line numbers) to stdout. */
-const emitDefinition = (def, plus, isFunc) => {
-    if (plus) {
-        writeWithLineNumbers(def, isFunc, writeOut);
-    }
-    else {
-        writeOut(def);
-    }
-};
-// ---------------------------------------------------------------------------
-// Shared core: \sf / \ef (function) and \sv / \ev (view).
-// ---------------------------------------------------------------------------
-/**
- * Resolve a function/view definition and dump it to stdout. Used by
- * both the show forms (`\sf` / `\sv`) and the edit forms (`\ef` / `\ev`)
- * when the user supplies a name.
- */
-const runShowFunction = async (ctx, cmdName, base) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const { plus } = decodeShowSuffix(cmdName, base);
-    const desc = readObjDesc(ctx);
-    if (desc === null) {
-        return errResult(ctx, "function name is required");
-    }
-    const oidLookup = await lookupFunctionOid(c, desc);
-    if (!oidLookup.ok)
-        return queryErrResult(ctx, oidLookup.err);
-    const defLookup = await getFunctionCreateCmd(c, oidLookup.oid);
-    if (!defLookup.ok)
-        return queryErrResult(ctx, defLookup.err);
-    emitDefinition(defLookup.def, plus, /*isFunc=*/ true);
-    return { status: "ok" };
-};
-const runShowView = async (ctx, cmdName, base) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const { plus } = decodeShowSuffix(cmdName, base);
-    const desc = readObjDesc(ctx);
-    if (desc === null) {
-        return errResult(ctx, "view name is required");
-    }
-    const oidLookup = await lookupRelationOid(c, desc);
-    if (!oidLookup.ok)
-        return queryErrResult(ctx, oidLookup.err);
-    const defLookup = await getViewCreateCmd(c, oidLookup.oid);
-    if (!defLookup.ok)
-        return queryErrResult(ctx, defLookup.err);
-    emitDefinition(defLookup.def, plus, /*isFunc=*/ false);
-    return { status: "ok" };
-};
-// ---------------------------------------------------------------------------
-// BackslashCmdSpec exports
-// ---------------------------------------------------------------------------
-/** `\sf [+] FUNCNAME` — show function source. */
-export const cmdShowFunction = {
-    name: "sf",
-    argMode: "whole-line",
-    helpKey: "sf",
-    run: (ctx) => runShowFunction(ctx, ctx.cmdName, "sf"),
-};
-/** `\sf+ FUNCNAME` — show function source with line numbers. */
-export const cmdShowFunctionPlus = {
-    name: "sf+",
-    argMode: "whole-line",
-    helpKey: "sf",
-    run: (ctx) => runShowFunction(ctx, ctx.cmdName, "sf"),
-};
-/** `\sv [+] VIEWNAME` — show view source. */
-export const cmdShowView = {
-    name: "sv",
-    argMode: "whole-line",
-    helpKey: "sv",
-    run: (ctx) => runShowView(ctx, ctx.cmdName, "sv"),
-};
-/** `\sv+ VIEWNAME` — show view source with line numbers. */
-export const cmdShowViewPlus = {
-    name: "sv+",
-    argMode: "whole-line",
-    helpKey: "sv",
-    run: (ctx) => runShowView(ctx, ctx.cmdName, "sv"),
-};
-/**
- * `\ef [+] [FUNCNAME [LINE]]` — upstream opens `$EDITOR` on the function's
- * source. We don't implement editor invocation; when a name is supplied we
- * route through the same fetch+print path as `\sf` (with a stripped line
- * number — the trailing LINE argument is ignored). Without a name we error
- * with a hint pointing at `\sf`.
- */
-export const cmdEditFunction = {
-    name: "ef",
-    argMode: "whole-line",
-    helpKey: "ef",
-    async run(ctx) {
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { plus } = decodeShowSuffix(ctx.cmdName, "ef");
-        const desc = readObjDesc(ctx);
-        if (desc === null) {
-            return errResult(ctx, "editing not supported in embedded psql; supply a name to display the source");
-        }
-        // Strip a possible trailing LINE number (upstream behaviour for \ef
-        // FUNCNAME LINE — the editor opens at that line; we just discard it).
-        const objDesc = stripTrailingLine(desc);
-        const oidLookup = await lookupFunctionOid(c, objDesc);
-        if (!oidLookup.ok)
-            return queryErrResult(ctx, oidLookup.err);
-        const defLookup = await getFunctionCreateCmd(c, oidLookup.oid);
-        if (!defLookup.ok)
-            return queryErrResult(ctx, defLookup.err);
-        emitDefinition(defLookup.def, plus, /*isFunc=*/ true);
-        return { status: "ok" };
-    },
-};
-/**
- * `\ev [+] [VIEWNAME [LINE]]` — same contract as `\ef` but for views.
- */
-export const cmdEditView = {
-    name: "ev",
-    argMode: "whole-line",
-    helpKey: "ev",
-    async run(ctx) {
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { plus } = decodeShowSuffix(ctx.cmdName, "ev");
-        const desc = readObjDesc(ctx);
-        if (desc === null) {
-            return errResult(ctx, "editing not supported in embedded psql; supply a name to display the source");
-        }
-        const objDesc = stripTrailingLine(desc);
-        const oidLookup = await lookupRelationOid(c, objDesc);
-        if (!oidLookup.ok)
-            return queryErrResult(ctx, oidLookup.err);
-        const defLookup = await getViewCreateCmd(c, oidLookup.oid);
-        if (!defLookup.ok)
-            return queryErrResult(ctx, defLookup.err);
-        emitDefinition(defLookup.def, plus, /*isFunc=*/ false);
-        return { status: "ok" };
-    },
-};
-/**
- * Aliases so that `\ef+` and `\ev+` resolve to the corresponding command;
- * we register the plus variants explicitly because the registry is keyed
- * by full name.
- */
-export const cmdEditFunctionPlus = {
-    ...cmdEditFunction,
-    name: "ef+",
-};
-export const cmdEditViewPlus = {
-    ...cmdEditView,
-    name: "ev+",
-};
-/**
- * Strip a trailing LINE number from an object descriptor, matching
- * upstream's `strip_lineno_from_objdesc`. We rebuild the simpler subset
- * here because the slash-arg scanner already handed us a single trimmed
- * whole-line string: if it ends with `<digits>` separated from the
- * preceding name by whitespace or `)`, strip the digits.
- *
- * Returns the descriptor with any trailing line number removed. Invalid
- * line numbers (zero) are not detected here — we treat them the same as
- * "no line number" because the LINE arg is meaningless to our
- * show-only impl.
- */
-const stripTrailingLine = (desc) => {
-    let i = desc.length - 1;
-    while (i > 0 && /\s/.test(desc[i]))
-        i--;
-    if (i <= 0 || !/[0-9]/.test(desc[i]))
-        return desc;
-    while (i > 0 && /[0-9]/.test(desc[i]))
-        i--;
-    // The char before the digit run must be whitespace or `)` and not the
-    // very first char.
-    if (i <= 0)
-        return desc;
-    const sep = desc[i];
-    if (!(/\s/.test(sep) || sep === ")"))
-        return desc;
-    return desc.slice(0, i + 1).trimEnd();
-};
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-/**
- * Register `\sf`, `\sf+`, `\sv`, `\sv+`, `\ef`, `\ef+`, `\ev`, `\ev+` on
- * the supplied registry. Wired into `defaultRegistry()` from `dispatch.ts`.
- */
-export const registerShowCommands = (registry) => {
-    registry.register(cmdShowFunction);
-    registry.register(cmdShowFunctionPlus);
-    registry.register(cmdShowView);
-    registry.register(cmdShowViewPlus);
-    registry.register(cmdEditFunction);
-    registry.register(cmdEditFunctionPlus);
-    registry.register(cmdEditView);
-    registry.register(cmdEditViewPlus);
-};