neonctl 2.28.0 → 2.29.1

package/dist/psql/wire/copy.js

@@ -26,7 +26,7 @@
  * doorbell — call `connection.startCopyIn(sql)` to get a `CopyInStream`, then
  * pipe a Readable into it via `pumpReadable()`.
  */
-import { Buffer } from 'node:buffer';
+import { Buffer } from "node:buffer";
 /**
  * Pump every chunk from a Node Readable into a CopyInStream, then end it.
  *
@@ -43,8 +43,8 @@ export const pumpReadable = async (conn, readable, copyIn) => {
     let aborted = null;
     try {
         for await (const chunk of readable) {
-            const buf = typeof chunk === 'string'
-                ? Buffer.from(chunk, 'utf8')
+            const buf = typeof chunk === "string"
+                ? Buffer.from(chunk, "utf8")
                 : Buffer.isBuffer(chunk)
                     ? chunk
                     : Buffer.from(chunk);
@@ -95,14 +95,14 @@ export const drainCopyOut = async (copyOut, writable) => {
 const abortReason = (v) => {
     if (v instanceof Error)
         return v.message;
-    if (typeof v === 'string')
+    if (typeof v === "string")
         return v;
-    if (typeof v === 'number' || typeof v === 'boolean')
+    if (typeof v === "number" || typeof v === "boolean")
         return String(v);
     try {
-        return JSON.stringify(v) ?? 'unknown error';
+        return JSON.stringify(v) ?? "unknown error";
     }
     catch {
-        return 'unknown error';
+        return "unknown error";
     }
 };

package/dist/psql/wire/pipeline.js

@@ -23,8 +23,8 @@
  *     concatenated ResultSets in execute-order. After end() the connection
  *     drops back to `idle`.
  */
-import { Buffer } from 'node:buffer';
-import { Bind, Close, Describe, Execute, Flush, Parse, Sync, } from './protocol.js';
+import { Buffer } from "node:buffer";
+import { Bind, Close, Describe, Execute, Flush, Parse, Sync, } from "./protocol.js";
 export class PipelineSession {
     constructor(conn) {
         this.conn = conn;
@@ -151,7 +151,7 @@ export class PipelineSession {
      */
     static voidToPlaceholderResult(p) {
         return p.then(() => ({
-            command: '',
+            command: "",
             rowCount: null,
             oid: null,
             fields: [],
@@ -208,7 +208,7 @@ export class PipelineSession {
         this.conn.startExtendedBatch();
         const p = this.conn.enqueueBind();
         const encoded = values.map(toBindValue);
-        this.conn.writeRaw(Bind('', name, [], encoded, [0]));
+        this.conn.writeRaw(Bind("", name, [], encoded, [0]));
         const silenced = PipelineSession.silenceUnhandled(p);
         this.pending.push(silenced);
         // Stage on the current command group so the next slot-pushing op
@@ -230,7 +230,7 @@ export class PipelineSession {
         // Stage DescribePortal on the current group too — its rejection
         // would otherwise be invisible to the slot.
         this.currentGroup.push(silencedDp);
-        this.conn.writeRaw(Describe('P', name));
+        this.conn.writeRaw(Describe("P", name));
         const ep = this.conn.enqueueExecute();
         this.results.push(PipelineSession.silenceUnhandled(ep));
         // Each Execute is one libpq-level user command (the Parse + Bind
@@ -248,7 +248,7 @@ export class PipelineSession {
         this.conn.startExtendedBatch();
         // psql's `\describe` in pipeline context is portal-targeted.
         const p = this.conn.enqueueDescribePortal();
-        this.conn.writeRaw(Describe('P', name));
+        this.conn.writeRaw(Describe("P", name));
         this.pending.push(PipelineSession.silenceUnhandled(p));
         return Promise.resolve();
     }
@@ -270,7 +270,7 @@ export class PipelineSession {
     closeRaw(name) {
         this.conn.startExtendedBatch();
         const p = this.conn.enqueueClose();
-        this.conn.writeRaw(Close('S', name));
+        this.conn.writeRaw(Close("S", name));
         const silenced = PipelineSession.silenceUnhandled(p);
         this.pending.push(silenced);
         this.currentGroup.push(silenced);
@@ -297,7 +297,7 @@ export class PipelineSession {
         // printing it (the empty-fields guard) but advances `drainedCount`
         // by one, matching upstream's libpq queue layout.
         const syncMarker = {
-            command: '',
+            command: "",
             rowCount: null,
             oid: null,
             fields: [],
@@ -334,7 +334,7 @@ export class PipelineSession {
         // rejection becomes the sticky `_lastError` if Sync itself was clean.
         const settled = await Promise.allSettled(this.pending.splice(0));
         for (const r of settled) {
-            if (r.status === 'rejected' && this._lastError === null) {
+            if (r.status === "rejected" && this._lastError === null) {
                 this._lastError = r.reason;
             }
         }
@@ -382,7 +382,7 @@ export class PipelineSession {
      */
     async peekRealError() {
         const allP = [...this.pending, ...this.results];
-        const sentinel = Symbol('pending');
+        const sentinel = Symbol("pending");
         // Race each candidate against a `setImmediate`-deferred sentinel so
         // any promise that was already settled (synchronously, e.g. by the
         // wire layer's cascade-reject inside its ErrorResponse handler) has
@@ -397,22 +397,23 @@ export class PipelineSession {
         for (const p of allP) {
             const r = (await Promise.race([
                 p.then((v) => ({
-                    status: 'fulfilled',
+                    status: "fulfilled",
                     value: v,
                 }), (e) => ({
-                    status: 'rejected',
+                    status: "rejected",
                     reason: e,
                 })),
                 deferred(),
             ]));
             if (r === sentinel)
                 continue;
-            if (r.status !== 'rejected')
+            if (r.status !== "rejected")
                 continue;
             const reason = r.reason;
-            const isAborted = typeof reason === 'object' &&
+            const isAborted = typeof reason === "object" &&
                 reason !== null &&
-                reason.pipelineAborted === true;
+                reason.pipelineAborted ===
+                    true;
             if (!isAborted)
                 return reason;
         }
@@ -440,7 +441,7 @@ export class PipelineSession {
         const settled = await Promise.allSettled(this.results);
         const out = [];
         for (const r of settled) {
-            if (r.status === 'fulfilled')
+            if (r.status === "fulfilled")
                 out.push(r.value);
         }
         // FATAL-class pipeline aborts (e.g. "COPY in a pipeline is not
@@ -451,10 +452,11 @@ export class PipelineSession {
         // `_lastError` so the cmd layer can print them inline.
         if (fatal !== null) {
             const sev = fatal.severity;
-            if (sev === 'FATAL') {
+            if (sev === "FATAL") {
                 if (fatal instanceof Error)
                     throw fatal;
-                const msg = fatal.message ?? 'pipeline aborted';
+                const msg = fatal.message ??
+                    "pipeline aborted";
                 throw Object.assign(new Error(msg), fatal);
             }
             // Non-FATAL (typically ERROR) — keep for the cmd layer, unless
@@ -488,7 +490,7 @@ export class PipelineSession {
             // first-wins capture.
             for (let i = this._externalDrained; i < settled.length; i++) {
                 const r = settled[i];
-                if (r.status === 'rejected') {
+                if (r.status === "rejected") {
                     this._lastError = r.reason;
                     break;
                 }
@@ -502,11 +504,11 @@ function toBindValue(v) {
         return null;
     if (Buffer.isBuffer(v))
         return v;
-    if (typeof v === 'string')
+    if (typeof v === "string")
         return v;
-    if (typeof v === 'boolean')
-        return v ? 't' : 'f';
-    if (typeof v === 'number' || typeof v === 'bigint')
+    if (typeof v === "boolean")
+        return v ? "t" : "f";
+    if (typeof v === "number" || typeof v === "bigint")
         return v.toString();
     // Objects, arrays, etc: JSON-stringify deterministically. Falls back to ''
     // if the value is not representable.
@@ -514,6 +516,6 @@ function toBindValue(v) {
         return JSON.stringify(v);
     }
     catch {
-        return '';
+        return "";
     }
 }

package/dist/psql/wire/protocol.js

@@ -39,7 +39,7 @@
  *     fields as named properties on the Error/Notice instance. We re-pack
  *     them into the Map<tag,value> shape our `fieldsToNotice` helper consumes.
  */
-import { Buffer } from 'node:buffer';
+import { Buffer } from "node:buffer";
 // pg-protocol@1.14 ships two entry points via its `exports` map:
 //   - `./esm/index.js` (the `"import"` key) — a thin ESM wrapper that does
 //     `import * as protocol from '../dist/index.js'`.
@@ -53,13 +53,13 @@ import { Buffer } from 'node:buffer';
 // key as a forced-ESM hint and avoids this. To stay portable across both,
 // we import the CJS implementation directly — same pattern node-postgres
 // uses for the `Parser` subpath, and what we already do on the next line.
-import pgProtocol from 'pg-protocol/dist/index.js';
+import pgProtocol from "pg-protocol/dist/index.js";
 const { serialize } = pgProtocol;
-import { Parser } from 'pg-protocol/dist/parser.js';
+import { Parser } from "pg-protocol/dist/parser.js";
 export class ProtocolError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'ProtocolError';
+        this.name = "ProtocolError";
     }
 }
 // ---------------------------------------------------------------------------
@@ -79,7 +79,7 @@ export function StartupMessage(params) {
     for (const [key, value] of Object.entries(params)) {
         if (value === undefined)
             continue;
-        if (key === 'client_encoding')
+        if (key === "client_encoding")
             continue;
         filtered[key] = value;
     }
@@ -166,11 +166,11 @@ export function PasswordMessage(password) {
  * losslessly via UTF-8.
  */
 export function SASLInitialResponse(mechanism, response) {
-    return serialize.sendSASLInitialResponseMessage(mechanism, response.toString('utf8'));
+    return serialize.sendSASLInitialResponseMessage(mechanism, response.toString("utf8"));
 }
 /** SASLResponse: 'p' + opaque body (no NUL terminator). */
 export function SASLResponse(response) {
-    return serialize.sendSCRAMClientFinalMessage(response.toString('utf8'));
+    return serialize.sendSCRAMClientFinalMessage(response.toString("utf8"));
 }
 /** CopyData: 'd' + opaque bytes. */
 export function CopyData(data) {
@@ -237,50 +237,50 @@ export class MessageParser {
 function adaptBackendMessage(raw) {
     const msg = raw;
     switch (msg.name) {
-        case 'authenticationOk':
-            return { type: 'AuthenticationOk' };
-        case 'authenticationCleartextPassword':
-            return { type: 'AuthenticationCleartextPassword' };
-        case 'authenticationMD5Password':
+        case "authenticationOk":
+            return { type: "AuthenticationOk" };
+        case "authenticationCleartextPassword":
+            return { type: "AuthenticationCleartextPassword" };
+        case "authenticationMD5Password":
             return {
-                type: 'AuthenticationMD5Password',
+                type: "AuthenticationMD5Password",
                 salt: Buffer.from(msg.salt),
             };
-        case 'authenticationSASL':
+        case "authenticationSASL":
             return {
-                type: 'AuthenticationSASL',
+                type: "AuthenticationSASL",
                 mechanisms: msg.mechanisms,
             };
-        case 'authenticationSASLContinue':
+        case "authenticationSASLContinue":
             return {
-                type: 'AuthenticationSASLContinue',
-                data: Buffer.from(msg.data, 'utf8'),
+                type: "AuthenticationSASLContinue",
+                data: Buffer.from(msg.data, "utf8"),
             };
-        case 'authenticationSASLFinal':
+        case "authenticationSASLFinal":
             return {
-                type: 'AuthenticationSASLFinal',
-                data: Buffer.from(msg.data, 'utf8'),
+                type: "AuthenticationSASLFinal",
+                data: Buffer.from(msg.data, "utf8"),
             };
-        case 'parameterStatus':
+        case "parameterStatus":
             return {
-                type: 'ParameterStatus',
+                type: "ParameterStatus",
                 name: msg.parameterName,
                 value: msg.parameterValue,
             };
-        case 'backendKeyData':
+        case "backendKeyData":
             return {
-                type: 'BackendKeyData',
+                type: "BackendKeyData",
                 processId: msg.processID,
                 secretKey: msg.secretKey,
             };
-        case 'readyForQuery': {
+        case "readyForQuery": {
             const status = msg.status;
-            if (status !== 'I' && status !== 'T' && status !== 'E') {
+            if (status !== "I" && status !== "T" && status !== "E") {
                 throw new ProtocolError(`ReadyForQuery: unexpected status ${JSON.stringify(status)}`);
             }
-            return { type: 'ReadyForQuery', status };
+            return { type: "ReadyForQuery", status };
         }
-        case 'rowDescription': {
+        case "rowDescription": {
             const fields = msg.fields.map((f) => ({
                 name: f.name,
                 tableID: f.tableID,
@@ -288,11 +288,11 @@ function adaptBackendMessage(raw) {
                 dataTypeID: f.dataTypeID,
                 dataTypeSize: f.dataTypeSize,
                 dataTypeModifier: f.dataTypeModifier,
-                format: f.format === 'binary' ? 1 : 0,
+                format: f.format === "binary" ? 1 : 0,
             }));
-            return { type: 'RowDescription', fields };
+            return { type: "RowDescription", fields };
         }
-        case 'dataRow': {
+        case "dataRow": {
             // pg-protocol always parses values as UTF-8 strings (or null for SQL
             // NULL). Our connection layer expects (Buffer | null)[] so it can hand
             // text-format columns through `.toString('utf8')` and pass binary
@@ -301,30 +301,30 @@ function adaptBackendMessage(raw) {
             const values = new Array(fields.length);
             for (let i = 0; i < fields.length; i++) {
                 const v = fields[i];
-                values[i] = v === null ? null : Buffer.from(v, 'utf8');
+                values[i] = v === null ? null : Buffer.from(v, "utf8");
             }
-            return { type: 'DataRow', values };
+            return { type: "DataRow", values };
         }
-        case 'commandComplete':
-            return { type: 'CommandComplete', tag: msg.text };
-        case 'emptyQuery':
-            return { type: 'EmptyQueryResponse' };
-        case 'error':
-            return { type: 'ErrorResponse', fields: errorOrNoticeFields(msg) };
-        case 'notice':
-            return { type: 'NoticeResponse', fields: errorOrNoticeFields(msg) };
-        case 'notification':
+        case "commandComplete":
+            return { type: "CommandComplete", tag: msg.text };
+        case "emptyQuery":
+            return { type: "EmptyQueryResponse" };
+        case "error":
+            return { type: "ErrorResponse", fields: errorOrNoticeFields(msg) };
+        case "notice":
+            return { type: "NoticeResponse", fields: errorOrNoticeFields(msg) };
+        case "notification":
             return {
-                type: 'NotificationResponse',
+                type: "NotificationResponse",
                 processId: msg.processId,
                 channel: msg.channel,
                 payload: msg.payload,
             };
-        case 'copyInResponse':
-            return adaptCopyResponse('CopyInResponse', msg);
-        case 'copyOutResponse':
-            return adaptCopyResponse('CopyOutResponse', msg);
-        case 'replicationStart':
+        case "copyInResponse":
+            return adaptCopyResponse("CopyInResponse", msg);
+        case "copyOutResponse":
+            return adaptCopyResponse("CopyOutResponse", msg);
+        case "replicationStart":
             // pg-protocol emits a bare marker for the 'W' (CopyBothResponse) byte
             // — its `Parser` recognises the message code but does not decode the
             // payload (overall format + per-column format bytes). The body shape
@@ -332,24 +332,24 @@ function adaptBackendMessage(raw) {
             // those fields: the connection layer reacts to CopyBothResponse by
             // raising a clean diagnostic because this client does not implement
             // CopyBoth streaming.
-            return { type: 'CopyBothResponse' };
-        case 'copyData':
-            return { type: 'CopyData', data: Buffer.from(msg.chunk) };
-        case 'copyDone':
-            return { type: 'CopyDone' };
-        case 'noData':
-            return { type: 'NoData' };
-        case 'parseComplete':
-            return { type: 'ParseComplete' };
-        case 'bindComplete':
-            return { type: 'BindComplete' };
-        case 'closeComplete':
-            return { type: 'CloseComplete' };
-        case 'portalSuspended':
-            return { type: 'PortalSuspended' };
-        case 'parameterDescription':
+            return { type: "CopyBothResponse" };
+        case "copyData":
+            return { type: "CopyData", data: Buffer.from(msg.chunk) };
+        case "copyDone":
+            return { type: "CopyDone" };
+        case "noData":
+            return { type: "NoData" };
+        case "parseComplete":
+            return { type: "ParseComplete" };
+        case "bindComplete":
+            return { type: "BindComplete" };
+        case "closeComplete":
+            return { type: "CloseComplete" };
+        case "portalSuspended":
+            return { type: "PortalSuspended" };
+        case "parameterDescription":
             return {
-                type: 'ParameterDescription',
+                type: "ParameterDescription",
                 oids: msg.dataTypeIDs,
             };
         default:
@@ -380,27 +380,27 @@ function errorOrNoticeFields(msg) {
     // tags), we copy S = V = severity when severity is defined. Consumers like
     // `fieldsToNotice` look at V then S so this matches.
     const set = (tag, value) => {
-        if (typeof value === 'string')
+        if (typeof value === "string")
             out.set(tag, value);
     };
-    set('S', msg.severity);
-    set('V', msg.severity);
-    set('C', msg.code);
-    set('M', msg.message);
-    set('D', msg.detail);
-    set('H', msg.hint);
-    set('P', msg.position);
-    set('p', msg.internalPosition);
-    set('q', msg.internalQuery);
-    set('W', msg.where);
-    set('s', msg.schema);
-    set('t', msg.table);
-    set('c', msg.column);
-    set('d', msg.dataType);
-    set('n', msg.constraint);
-    set('F', msg.file);
-    set('L', msg.line);
-    set('R', msg.routine);
+    set("S", msg.severity);
+    set("V", msg.severity);
+    set("C", msg.code);
+    set("M", msg.message);
+    set("D", msg.detail);
+    set("H", msg.hint);
+    set("P", msg.position);
+    set("p", msg.internalPosition);
+    set("q", msg.internalQuery);
+    set("W", msg.where);
+    set("s", msg.schema);
+    set("t", msg.table);
+    set("c", msg.column);
+    set("d", msg.dataType);
+    set("n", msg.constraint);
+    set("F", msg.file);
+    set("L", msg.line);
+    set("R", msg.routine);
     return out;
 }
 // ---------------------------------------------------------------------------
@@ -414,52 +414,52 @@ function errorOrNoticeFields(msg) {
 export function fieldsToNotice(fields) {
     // Per PG docs: V is the non-localized severity (preferred when present),
     // S is the localized severity (always present). Message M is mandatory.
-    const severity = fields.get('V') ?? fields.get('S') ?? '';
-    const message = fields.get('M') ?? '';
+    const severity = fields.get("V") ?? fields.get("S") ?? "";
+    const message = fields.get("M") ?? "";
     const out = { severity, message };
-    const code = fields.get('C');
+    const code = fields.get("C");
     if (code !== undefined)
         out.code = code;
-    const detail = fields.get('D');
+    const detail = fields.get("D");
     if (detail !== undefined)
         out.detail = detail;
-    const hint = fields.get('H');
+    const hint = fields.get("H");
     if (hint !== undefined)
         out.hint = hint;
-    const position = fields.get('P');
+    const position = fields.get("P");
     if (position !== undefined)
         out.position = position;
-    const internalPosition = fields.get('p');
+    const internalPosition = fields.get("p");
     if (internalPosition !== undefined)
         out.internalPosition = internalPosition;
-    const internalQuery = fields.get('q');
+    const internalQuery = fields.get("q");
     if (internalQuery !== undefined)
         out.internalQuery = internalQuery;
-    const where = fields.get('W');
+    const where = fields.get("W");
     if (where !== undefined)
         out.where = where;
-    const schema = fields.get('s');
+    const schema = fields.get("s");
     if (schema !== undefined)
         out.schema = schema;
-    const table = fields.get('t');
+    const table = fields.get("t");
     if (table !== undefined)
         out.table = table;
-    const column = fields.get('c');
+    const column = fields.get("c");
     if (column !== undefined)
         out.column = column;
-    const dataType = fields.get('d');
+    const dataType = fields.get("d");
     if (dataType !== undefined)
         out.dataType = dataType;
-    const constraint = fields.get('n');
+    const constraint = fields.get("n");
     if (constraint !== undefined)
         out.constraint = constraint;
-    const file = fields.get('F');
+    const file = fields.get("F");
     if (file !== undefined)
         out.file = file;
-    const line = fields.get('L');
+    const line = fields.get("L");
     if (line !== undefined)
         out.line = line;
-    const routine = fields.get('R');
+    const routine = fields.get("R");
     if (routine !== undefined)
         out.routine = routine;
     return out;