postgrejs 2.12.0

package/esm/protocol/frontend.js

@@ -0,0 +1,214 @@
+import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
+import { encodeBinaryArray } from '../util/encode-binaryarray.js';
+import { stringifyArrayLiteral } from '../util/stringify-arrayliteral.js';
+import { Protocol } from './protocol.js';
+import { SmartBuffer } from './smart-buffer.js';
+const DataFormat = Protocol.DataFormat;
+const StaticFlushBuffer = Buffer.from([Protocol.FrontendMessageCode.Flush, 0x00, 0x00, 0x00, 0x04]);
+const StaticTerminateBuffer = Buffer.from([Protocol.FrontendMessageCode.Terminate, 0x00, 0x00, 0x00, 0x04]);
+const StaticSyncBuffer = Buffer.from([Protocol.FrontendMessageCode.Sync, 0x00, 0x00, 0x00, 0x04]);
+export class Frontend {
+    constructor(options) {
+        this._io = new SmartBuffer(options?.buffer);
+    }
+    getSSLRequestMessage() {
+        return this._io
+            .start()
+            .writeUInt32BE(8) // Length of message contents in bytes, including self.
+            .writeUInt16BE(1234)
+            .writeUInt16BE(5679)
+            .flush();
+    }
+    getStartupMessage(args) {
+        const io = this._io
+            .start()
+            .writeInt32BE(0) // Preserve length
+            .writeInt16BE(Protocol.VERSION_MAJOR)
+            .writeInt16BE(Protocol.VERSION_MINOR);
+        for (const [k, v] of Object.entries(args)) {
+            if (k !== 'client_encoding')
+                io.writeCString(k, 'utf8').writeCString(v, 'utf8');
+        }
+        io.writeCString('client_encoding', 'utf8').writeCString('UTF8', 'utf8').writeUInt8(0);
+        return setLengthAndFlush(io, 0);
+    }
+    getPasswordMessage(password) {
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.PasswordMessage)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(password, 'utf8');
+        return setLengthAndFlush(io, 1);
+    }
+    getSASLMessage(sasl) {
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.PasswordMessage)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(sasl.mechanism, 'utf8')
+            .writeLString(sasl.clientFirstMessage);
+        return setLengthAndFlush(io, 1);
+    }
+    getSASLFinalMessage(session) {
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.PasswordMessage)
+            .writeInt32BE(0) // Preserve header
+            .writeString(session.clientFinalMessage);
+        return setLengthAndFlush(io, 1);
+    }
+    getParseMessage(args) {
+        if (args.statement && args.statement.length > 63)
+            throw new Error('Query name length must be lower than 63');
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.Parse)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(args.statement || '', 'utf8')
+            .writeCString(args.sql, 'utf8')
+            .writeUInt16BE(args.paramTypes ? args.paramTypes.length : 0);
+        if (args.paramTypes) {
+            for (const t of args.paramTypes) {
+                io.writeUInt32BE(t || 0);
+            }
+        }
+        return setLengthAndFlush(io, 1);
+    }
+    getBindMessage(args) {
+        if (args.portal && args.portal.length > 63)
+            throw new Error('Portal name length must be lower than 63');
+        if (args.statement && args.statement.length > 63)
+            throw new Error('Query name length must be lower than 63');
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.Bind)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(args.portal || '', 'utf8')
+            .writeCString(args.statement || '', 'utf8');
+        const { params, paramTypes, queryOptions } = args;
+        const columnFormat = queryOptions.columnFormat != null ? queryOptions.columnFormat : DEFAULT_COLUMN_FORMAT;
+        if (params && params.length) {
+            io.writeInt16BE(params.length);
+            const formatOffset = io.offset;
+            for (let i = 0; i < params.length; i++) {
+                io.writeInt16BE(0); // Preserve
+            }
+            // Write parameter values
+            io.writeUInt16BE(params.length);
+            for (let i = 0; i < params?.length; i++) {
+                let v = params[i];
+                if (v == null) {
+                    io.writeInt32BE(-1);
+                    continue;
+                }
+                const dataTypeOid = paramTypes ? paramTypes[i] : undefined;
+                const dt = dataTypeOid ? args.typeMap.get(dataTypeOid) : undefined;
+                if (dt) {
+                    if (typeof dt.encodeBinary === 'function') {
+                        // Set param format to binary
+                        io.buffer.writeInt16BE(Protocol.DataFormat.binary, formatOffset + i * 2);
+                        // Preserve data length
+                        io.writeInt32BE(0);
+                        const dataOffset = io.offset;
+                        if (dt.elementsOID) {
+                            // If data type is array
+                            v = Array.isArray(v) ? v : [v];
+                            encodeBinaryArray(io, v, dt.elementsOID, queryOptions, dt.encodeBinary, dt.encodeCalculateDim);
+                        }
+                        else {
+                            dt.encodeBinary(io, v, queryOptions);
+                        }
+                        io.buffer.writeInt32BE(io.length - dataOffset, dataOffset - 4); // Update length
+                    }
+                    else if (typeof dt.encodeText === 'function') {
+                        v = dt.elementsOID ? stringifyArrayLiteral(v, queryOptions, dt.encodeText) : dt.encodeText(v, queryOptions);
+                        io.writeLString(v, 'utf8');
+                    }
+                }
+                else if (Buffer.isBuffer(v)) {
+                    // Set param format to binary
+                    io.buffer.writeInt16BE(Protocol.DataFormat.binary, formatOffset + i * 2);
+                    // Preserve data length
+                    io.writeInt32BE(0);
+                    const dataOffset = io.offset;
+                    io.writeBuffer(v);
+                    io.buffer.writeInt32BE(io.length - dataOffset, dataOffset - 4); // Update length
+                }
+                else {
+                    io.writeLString('' + v, 'utf8');
+                }
+            }
+        }
+        else {
+            io.writeUInt16BE(0);
+            io.writeUInt16BE(0);
+        }
+        if (Array.isArray(columnFormat)) {
+            io.writeUInt16BE(columnFormat.length);
+            for (let i = 0; i < columnFormat.length; i++) {
+                io.writeUInt16BE(columnFormat[i]);
+            }
+        }
+        else if (columnFormat === DataFormat.binary) {
+            io.writeUInt16BE(1);
+            io.writeUInt16BE(DataFormat.binary);
+        }
+        else
+            io.writeUInt16BE(0);
+        return setLengthAndFlush(io, 1);
+    }
+    getDescribeMessage(args) {
+        if (args.name && args.name.length > 63)
+            throw new Error(args.type === 'P' ? 'Portal' : 'Statement' + 'name length must be lower than 63');
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.Describe)
+            .writeInt32BE(0) // Preserve header
+            .writeUInt8(args.type.charCodeAt(0))
+            .writeCString(args.name || '', 'utf8');
+        return setLengthAndFlush(io, 1);
+    }
+    getExecuteMessage(args) {
+        if (args.fetchCount && (args.fetchCount < 0 || args.fetchCount > 4294967295))
+            throw new Error('fetchCount can be between 0 and 4294967295');
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.Execute)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(args.portal || '', 'utf8')
+            .writeUInt32BE(args.fetchCount || 0);
+        return setLengthAndFlush(io, 1);
+    }
+    getCloseMessage(args) {
+        if (args.name && args.name.length > 63)
+            throw new Error(args.type === 'P' ? 'Portal' : 'Statement' + 'name length must be lower than 63');
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.Close)
+            .writeInt32BE(0) // Preserve header
+            .writeUInt8(args.type.charCodeAt(0))
+            .writeCString(args.name || '', 'utf8');
+        return setLengthAndFlush(io, 1);
+    }
+    getQueryMessage(sql) {
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.Query)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(sql || '', 'utf8');
+        return setLengthAndFlush(io, 1);
+    }
+    getFlushMessage() {
+        return StaticFlushBuffer;
+    }
+    getTerminateMessage() {
+        return StaticTerminateBuffer;
+    }
+    getSyncMessage() {
+        return StaticSyncBuffer;
+    }
+}
+function setLengthAndFlush(io, lengthOffset) {
+    io.buffer.writeUInt32BE(io.length - lengthOffset, lengthOffset);
+    return io.flush();
+}

package/esm/protocol/pg-socket.js

@@ -0,0 +1,338 @@
+import crypto from 'crypto';
+import net from 'net';
+import promisify from 'putil-promisify';
+import tls from 'tls';
+import { ConnectionState } from '../constants.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { Backend } from './backend.js';
+import { DatabaseError } from './database-error.js';
+import { Frontend } from './frontend.js';
+import { Protocol } from './protocol.js';
+import { SASL } from './sasl.js';
+const DEFAULT_PORT_NUMBER = 5432;
+const COMMAND_RESULT_PATTERN = /^([^\d]+)(?: (\d+)(?: (\d+))?)?$/;
+export class PgSocket extends SafeEventEmitter {
+    constructor(options) {
+        super();
+        this.options = options;
+        this._state = ConnectionState.CLOSED;
+        this._backend = new Backend();
+        this._sessionParameters = {};
+        this._frontend = new Frontend({ buffer: options.buffer });
+        this.setMaxListeners(99);
+    }
+    get state() {
+        if (!this._socket || this._socket.destroyed)
+            this._state = ConnectionState.CLOSED;
+        return this._state;
+    }
+    get processID() {
+        return this._processID;
+    }
+    get secretKey() {
+        return this._secretKey;
+    }
+    get sessionParameters() {
+        return this._sessionParameters;
+    }
+    connect() {
+        if (this._socket)
+            return;
+        this._state = ConnectionState.CONNECTING;
+        const options = this.options;
+        const socket = (this._socket = new net.Socket());
+        const errorHandler = err => {
+            this._state = ConnectionState.CLOSED;
+            this._removeListeners();
+            this._reset();
+            socket.destroy();
+            this._socket = undefined;
+            this.emit('error', err);
+        };
+        const connectHandler = () => {
+            socket.setTimeout(0);
+            if (this.options.keepAlive || this.options.keepAlive == null)
+                socket.setKeepAlive(true);
+            if (options.ssl) {
+                socket.write(this._frontend.getSSLRequestMessage());
+                socket.once('data', x => {
+                    this._removeListeners();
+                    if (x.toString() === 'S') {
+                        const tslOptions = { ...options.ssl, socket };
+                        if (options.host && net.isIP(options.host) === 0)
+                            tslOptions.servername = options.host;
+                        const tlsSocket = (this._socket = tls.connect(tslOptions));
+                        tlsSocket.once('error', errorHandler);
+                        tlsSocket.once('secureConnect', () => {
+                            this._removeListeners();
+                            this._handleConnect();
+                        });
+                        return;
+                    }
+                    if (x.toString() === 'N')
+                        return errorHandler(new Error('Server does not support SSL connections'));
+                    return errorHandler(new Error('There was an error establishing an SSL connection'));
+                });
+            }
+            else {
+                this._handleConnect();
+            }
+        };
+        socket.setNoDelay(true);
+        socket.setTimeout(options.connectTimeoutMs || 30000, () => errorHandler(new Error('Connection timed out')));
+        socket.once('error', errorHandler);
+        socket.once('connect', connectHandler);
+        this.emit('connecting');
+        if (options.host && options.host.startsWith('/'))
+            socket.connect(options.host);
+        else
+            socket.connect(options.port || DEFAULT_PORT_NUMBER, options.host || 'localhost');
+    }
+    close() {
+        if (!this._socket || this._socket.destroyed) {
+            this._state = ConnectionState.CLOSED;
+            this._socket = undefined;
+            this._reset();
+            return;
+        }
+        if (this._state === ConnectionState.CLOSING)
+            return;
+        const socket = this._socket;
+        this._state = ConnectionState.CLOSING;
+        this._removeListeners();
+        socket.once('close', () => this._handleClose());
+        socket.destroy();
+    }
+    sendParseMessage(args, cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendParseMessage', args });
+        this._send(this._frontend.getParseMessage(args), cb);
+    }
+    sendBindMessage(args, cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendBindMessage', args });
+        this._send(this._frontend.getBindMessage(args), cb);
+    }
+    sendDescribeMessage(args, cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendDescribeMessage', args });
+        this._send(this._frontend.getDescribeMessage(args), cb);
+    }
+    sendExecuteMessage(args, cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendDescribeMessage', args });
+        this._send(this._frontend.getExecuteMessage(args), cb);
+    }
+    sendCloseMessage(args, cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendCloseMessage', args });
+        this._send(this._frontend.getCloseMessage(args), cb);
+    }
+    sendQueryMessage(sql, cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendQueryMessage', sql });
+        this._send(this._frontend.getQueryMessage(sql), cb);
+    }
+    sendFlushMessage(cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendFlushMessage' });
+        this._send(this._frontend.getFlushMessage(), cb);
+    }
+    sendTerminateMessage(cb) {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendTerminateMessage' });
+        this._send(this._frontend.getTerminateMessage(), cb);
+    }
+    sendSyncMessage() {
+        if (this.listenerCount('debug'))
+            this.emit('debug', { location: 'PgSocket.sendSyncMessage' });
+        this._send(this._frontend.getSyncMessage());
+    }
+    capture(callback) {
+        return new Promise((resolve, reject) => {
+            const done = (err, result) => {
+                this.removeListener('error', errorHandler);
+                this.removeListener('message', msgHandler);
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            };
+            const errorHandler = (err) => {
+                this.removeListener('message', msgHandler);
+                reject(err);
+            };
+            const msgHandler = (code, msg) => {
+                const x = callback(code, msg, done);
+                if (promisify.isPromise(x))
+                    x.catch(err => done(err));
+            };
+            this.once('error', errorHandler);
+            this.on('message', msgHandler);
+        });
+    }
+    _removeListeners() {
+        if (!this._socket)
+            return;
+        this._socket.removeAllListeners('error');
+        this._socket.removeAllListeners('connect');
+        this._socket.removeAllListeners('data');
+        this._socket.removeAllListeners('close');
+    }
+    _reset() {
+        this._backend.reset();
+        this._sessionParameters = {};
+        this._processID = undefined;
+        this._secretKey = undefined;
+        this._saslSession = undefined;
+    }
+    _handleConnect() {
+        const socket = this._socket;
+        if (!socket)
+            return;
+        this._state = ConnectionState.AUTHORIZING;
+        this._reset();
+        socket.on('data', (data) => this._handleData(data));
+        socket.on('error', (err) => this._handleError(err));
+        socket.on('close', () => this._handleClose());
+        this._send(this._frontend.getStartupMessage({
+            user: this.options.user || 'postgres',
+            database: this.options.database || '',
+        }));
+    }
+    _handleClose() {
+        this._reset();
+        this._socket = undefined;
+        this._state = ConnectionState.CLOSED;
+        this.emit('close');
+    }
+    _handleError(err) {
+        if (this._state !== ConnectionState.READY) {
+            this._socket?.end();
+        }
+        this.emit('error', err);
+    }
+    _handleData(data) {
+        this._backend.parse(data, (code, payload) => {
+            try {
+                switch (code) {
+                    case Protocol.BackendMessageCode.Authentication:
+                        this._handleAuthenticationMessage(payload);
+                        break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        this.emit('error', new DatabaseError(payload));
+                        break;
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        this.emit('notice', payload);
+                        break;
+                    case Protocol.BackendMessageCode.NotificationResponse:
+                        this.emit('notification', payload);
+                        break;
+                    case Protocol.BackendMessageCode.ParameterStatus:
+                        this._handleParameterStatus(payload);
+                        break;
+                    case Protocol.BackendMessageCode.BackendKeyData:
+                        this._handleBackendKeyData(payload);
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        if (this._state !== ConnectionState.READY) {
+                            this._state = ConnectionState.READY;
+                            this.emit('ready');
+                        }
+                        else
+                            this.emit('message', code, payload);
+                        break;
+                    case Protocol.BackendMessageCode.CommandComplete: {
+                        const msg = this._handleCommandComplete(payload);
+                        this.emit('message', code, msg);
+                        break;
+                    }
+                    default:
+                        this.emit('message', code, payload);
+                }
+            }
+            catch (e) {
+                this._handleError(e);
+            }
+        });
+    }
+    _resolvePassword(cb) {
+        (async () => {
+            const pass = typeof this.options.password === 'function' ? await this.options.password() : this.options.password;
+            cb(pass || '');
+        })().catch(err => this._handleError(err));
+    }
+    _handleAuthenticationMessage(msg) {
+        if (!msg) {
+            this.emit('authenticate');
+            return;
+        }
+        switch (msg.kind) {
+            case Protocol.AuthenticationMessageKind.CleartextPassword:
+                this._resolvePassword(password => {
+                    this._send(this._frontend.getPasswordMessage(password));
+                });
+                break;
+            case Protocol.AuthenticationMessageKind.MD5Password:
+                this._resolvePassword(password => {
+                    const md5 = (x) => crypto.createHash('md5').update(x, 'utf8').digest('hex');
+                    const l = md5(password + this.options.user);
+                    const r = md5(Buffer.concat([Buffer.from(l), msg.salt]));
+                    const pass = 'md5' + r;
+                    this._send(this._frontend.getPasswordMessage(pass));
+                });
+                break;
+            case Protocol.AuthenticationMessageKind.SASL: {
+                if (!msg.mechanisms.includes('SCRAM-SHA-256'))
+                    throw new Error('SASL: Only mechanism SCRAM-SHA-256 is currently supported');
+                const saslSession = (this._saslSession = SASL.createSession(this.options.user || '', 'SCRAM-SHA-256'));
+                this._send(this._frontend.getSASLMessage(saslSession));
+                break;
+            }
+            case Protocol.AuthenticationMessageKind.SASLContinue: {
+                const saslSession = this._saslSession;
+                if (!saslSession)
+                    throw new Error('SASL: Session not started yet');
+                this._resolvePassword(password => {
+                    SASL.continueSession(saslSession, password, msg.data);
+                    const buf = this._frontend.getSASLFinalMessage(saslSession);
+                    this._send(buf);
+                });
+                break;
+            }
+            case Protocol.AuthenticationMessageKind.SASLFinal: {
+                const session = this._saslSession;
+                if (!session)
+                    throw new Error('SASL: Session not started yet');
+                SASL.finalizeSession(session, msg.data);
+                this._saslSession = undefined;
+                break;
+            }
+        }
+    }
+    _handleParameterStatus(msg) {
+        this._sessionParameters[msg.name] = msg.value;
+    }
+    _handleBackendKeyData(msg) {
+        this._processID = msg.processID;
+        this._secretKey = msg.secretKey;
+    }
+    _handleCommandComplete(msg) {
+        const m = msg.command && msg.command.match(COMMAND_RESULT_PATTERN);
+        const result = {
+            command: m[1],
+        };
+        if (m[3] != null) {
+            result.oid = parseInt(m[2], 10);
+            result.rowCount = parseInt(m[3], 10);
+        }
+        else if (m[2])
+            result.rowCount = parseInt(m[2], 10);
+        return result;
+    }
+    _send(data, cb) {
+        if (this._socket && this._socket.writable) {
+            this._socket.write(data, cb);
+        }
+    }
+}

package/esm/protocol/protocol.js

@@ -0,0 +1,68 @@
+export var Protocol;
+(function (Protocol) {
+    Protocol.VERSION_MAJOR = 3;
+    Protocol.VERSION_MINOR = 0;
+    // https://www.postgresql.org/docs/9.3/protocol-message-formats.html
+    let BackendMessageCode;
+    (function (BackendMessageCode) {
+        BackendMessageCode[BackendMessageCode["Authentication"] = 82] = "Authentication";
+        BackendMessageCode[BackendMessageCode["BackendKeyData"] = 75] = "BackendKeyData";
+        BackendMessageCode[BackendMessageCode["BindComplete"] = 50] = "BindComplete";
+        BackendMessageCode[BackendMessageCode["CloseComplete"] = 51] = "CloseComplete";
+        BackendMessageCode[BackendMessageCode["CommandComplete"] = 67] = "CommandComplete";
+        BackendMessageCode[BackendMessageCode["CopyData"] = 100] = "CopyData";
+        BackendMessageCode[BackendMessageCode["CopyDone"] = 99] = "CopyDone";
+        BackendMessageCode[BackendMessageCode["CopyInResponse"] = 103] = "CopyInResponse";
+        BackendMessageCode[BackendMessageCode["CopyOutResponse"] = 72] = "CopyOutResponse";
+        BackendMessageCode[BackendMessageCode["CopyBothResponse"] = 87] = "CopyBothResponse";
+        BackendMessageCode[BackendMessageCode["DataRow"] = 68] = "DataRow";
+        BackendMessageCode[BackendMessageCode["EmptyQueryResponse"] = 73] = "EmptyQueryResponse";
+        BackendMessageCode[BackendMessageCode["ErrorResponse"] = 69] = "ErrorResponse";
+        BackendMessageCode[BackendMessageCode["FunctionCallResponse"] = 86] = "FunctionCallResponse";
+        BackendMessageCode[BackendMessageCode["NegotiateProtocolVersion"] = 118] = "NegotiateProtocolVersion";
+        BackendMessageCode[BackendMessageCode["NoData"] = 110] = "NoData";
+        BackendMessageCode[BackendMessageCode["NoticeResponse"] = 78] = "NoticeResponse";
+        BackendMessageCode[BackendMessageCode["NotificationResponse"] = 65] = "NotificationResponse";
+        BackendMessageCode[BackendMessageCode["ParameterDescription"] = 116] = "ParameterDescription";
+        BackendMessageCode[BackendMessageCode["ParameterStatus"] = 83] = "ParameterStatus";
+        BackendMessageCode[BackendMessageCode["ParseComplete"] = 49] = "ParseComplete";
+        BackendMessageCode[BackendMessageCode["PortalSuspended"] = 115] = "PortalSuspended";
+        BackendMessageCode[BackendMessageCode["ReadyForQuery"] = 90] = "ReadyForQuery";
+        BackendMessageCode[BackendMessageCode["RowDescription"] = 84] = "RowDescription";
+    })(BackendMessageCode = Protocol.BackendMessageCode || (Protocol.BackendMessageCode = {}));
+    let FrontendMessageCode;
+    (function (FrontendMessageCode) {
+        FrontendMessageCode[FrontendMessageCode["Bind"] = 66] = "Bind";
+        FrontendMessageCode[FrontendMessageCode["Close"] = 67] = "Close";
+        FrontendMessageCode[FrontendMessageCode["CopyData"] = 100] = "CopyData";
+        FrontendMessageCode[FrontendMessageCode["CopyDone"] = 99] = "CopyDone";
+        FrontendMessageCode[FrontendMessageCode["CopyFail"] = 102] = "CopyFail";
+        FrontendMessageCode[FrontendMessageCode["Describe"] = 68] = "Describe";
+        FrontendMessageCode[FrontendMessageCode["Execute"] = 69] = "Execute";
+        FrontendMessageCode[FrontendMessageCode["Flush"] = 72] = "Flush";
+        FrontendMessageCode[FrontendMessageCode["FunctionCall"] = 70] = "FunctionCall";
+        FrontendMessageCode[FrontendMessageCode["Parse"] = 80] = "Parse";
+        FrontendMessageCode[FrontendMessageCode["PasswordMessage"] = 112] = "PasswordMessage";
+        FrontendMessageCode[FrontendMessageCode["Query"] = 81] = "Query";
+        FrontendMessageCode[FrontendMessageCode["Sync"] = 83] = "Sync";
+        FrontendMessageCode[FrontendMessageCode["Terminate"] = 88] = "Terminate";
+    })(FrontendMessageCode = Protocol.FrontendMessageCode || (Protocol.FrontendMessageCode = {}));
+    let AuthenticationMessageKind;
+    (function (AuthenticationMessageKind) {
+        AuthenticationMessageKind["KerberosV5"] = "KerberosV5";
+        AuthenticationMessageKind["CleartextPassword"] = "CleartextPassword";
+        AuthenticationMessageKind["MD5Password"] = "MD5Password";
+        AuthenticationMessageKind["SCMCredential"] = "SCMCredential";
+        AuthenticationMessageKind["GSS"] = "GSS";
+        AuthenticationMessageKind["SSPI"] = "SSPI";
+        AuthenticationMessageKind["GSSContinue"] = "GSSContinue";
+        AuthenticationMessageKind["SASL"] = "SASL";
+        AuthenticationMessageKind["SASLContinue"] = "SASLContinue";
+        AuthenticationMessageKind["SASLFinal"] = "SASLFinal";
+    })(AuthenticationMessageKind = Protocol.AuthenticationMessageKind || (Protocol.AuthenticationMessageKind = {}));
+    let DataFormat;
+    (function (DataFormat) {
+        DataFormat[DataFormat["text"] = 0] = "text";
+        DataFormat[DataFormat["binary"] = 1] = "binary";
+    })(DataFormat = Protocol.DataFormat || (Protocol.DataFormat = {}));
+})(Protocol || (Protocol = {}));