@m2k-5f/pgtx 1.4.12 → 2.0.1

package/dist/index.js

@@ -1,21 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = exports.Transaction = exports.Connection = exports.sql = void 0;
+exports.setTypeParser = exports.Pool = exports.Transaction = exports.Connection = exports.sql = void 0;
 const pool_1 = require("./pool");
 Object.defineProperty(exports, "Pool", { enumerable: true, get: function () { return pool_1.Pool; } });
-const empty_clause_1 = require("./clauses/empty.clause");
-const where_clause_1 = require("./clauses/where.clause");
-const insert_clause_1 = require("./clauses/insert.clause");
-const update_clause_1 = require("./clauses/update.clause");
-const exclude_clause_1 = require("./clauses/exclude.clause");
-const iden_caluse_1 = require("./clauses/iden.caluse");
-const literal_clause_1 = require("./clauses/literal.clause");
-const fragment_clause_1 = require("./clauses/fragment.clause");
-const array_clause_1 = require("./clauses/array.clause");
+const clauses_1 = require("./clauses");
 const connection_1 = require("./connection");
 Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return connection_1.Connection; } });
 const transaction_1 = require("./transaction");
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });
+const value_parser_1 = require("./utils/value-parser");
+Object.defineProperty(exports, "setTypeParser", { enumerable: true, get: function () { return value_parser_1.setTypeParser; } });
 /**
  * Core SQL tagging utility for Pgtx.
  * Provides type-safe helpers for building dynamic queries with recursive support.
@@ -33,7 +27,7 @@ exports.sql = {
      * sql.insert([{ id: 1 }, { id: 2 }])
      * // Result: (id) VALUES ($1), ($2)
      */
-    insert: insert_clause_1.InsertClause.create,
+    insert: clauses_1.InsertClause.create,
     /**
      * Generates a SET clause for UPDATE queries from a JavaScript object.
      *
@@ -41,7 +35,7 @@ exports.sql = {
      * sql.update({ status: 'active', updated_at: new Date() })
      * // Result: status = $1, updated_at = $2
      */
-    update: update_clause_1.UpdateClause.create,
+    update: clauses_1.UpdateClause.create,
     /**
      * Generates an assignment list for ON CONFLICT DO UPDATE using the EXCLUDED table.
      *
@@ -49,7 +43,7 @@ exports.sql = {
      * sql`INSERT INTO users ${sql.insert(data)} ON CONFLICT (id) DO UPDATE SET ${sql.excluded(['name', 'email'])}`
      * // Result: name = EXCLUDED.name, email = EXCLUDED.email
      */
-    excluded: exclude_clause_1.ExcludeUpdateClause.create,
+    excluded: clauses_1.ExcludeUpdateClause.create,
     /**
      * Represents a safe empty SQL fragment.
      * Useful for dynamic query building when a condition or list might be optional.
@@ -59,7 +53,7 @@ exports.sql = {
      * sql`SELECT * FROM users ${filters.length ? sql.fragment`WHERE ...` : sql.empty}`
      * // Result: SELECT * FROM users
      */
-    empty: empty_clause_1.emptyClause,
+    empty: clauses_1.emptyClause,
     /**
    * Generates a list of conditions for a WHERE clause from a JavaScript object.
    * Works similarly to sql.update, but uses ' AND ' as a separator instead of a comma.
@@ -72,7 +66,7 @@ exports.sql = {
    * sql`DELETE FROM tasks WHERE ${sql.where({ id: 10, user_id: 5 })}`
    * // Result: id = $1 AND user_id = $2
    */
-    where: where_clause_1.WhereClause.create,
+    where: clauses_1.WhereClause.create,
     /**
      * Safely escapes SQL identifiers (table or column names) using double quotes.
      *
@@ -84,7 +78,7 @@ exports.sql = {
      * sql.ident('table.column')
      * // Result: "table.column"
      */
-    ident: iden_caluse_1.IdentifierClause.create,
+    ident: clauses_1.IdentifierClause.create,
     /**
      * Injects raw, unescaped SQL strings.
      * ⚠️ Use with caution to prevent SQL injection!
@@ -93,7 +87,7 @@ exports.sql = {
      * sql.literal('DESC')
      * // Result: DESC
      */
-    literal: literal_clause_1.LiteralClause.create,
+    literal: clauses_1.LiteralClause.create,
     /**
      * Creates a reusable, recursive SQL fragment.
      * Fragments can be nested within each other; argument numbering is handled automatically.
@@ -103,7 +97,7 @@ exports.sql = {
      * sql`SELECT * FROM users WHERE ${filter} AND status = ${'active'}`
      * // Result: SELECT * FROM users WHERE age > $1 AND status = $2
      */
-    fragment: fragment_clause_1.FragmentClause.create,
+    fragment: clauses_1.FragmentClause.create,
     /**
      * Formats an array for dynamic lists (IN clauses, column lists, or joined conditions).
      * Supports recursive Clauses (fragments, idents) within the array.
@@ -124,5 +118,5 @@ exports.sql = {
      * sql`SELECT ${sql.array([sql.ident('id'), sql.ident('name')])}`
      * // Result: SELECT "id", "name"
      */
-    array: array_clause_1.ArrayClause.create,
+    array: clauses_1.ArrayClause.create,
 };

package/dist/pool.d.ts

@@ -1,60 +1,154 @@
-import { QueryResultRow } from "pg";
-import { PoolConfig, PreparedStatement } from "./types";
-import { Connection } from "./connection";
+import { Connection, ConnectionParams } from "./connection";
 import { Transaction } from "./transaction";
+type PoolParams = ConnectionParams & {
+    max?: number;
+};
 /**
  * The main entry point for Pgtx.
  * Manages a connection pool and provides high-level API for queries and transactions.
+ *
+ * @example
+ * ```ts
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   user: 'postgres',
+ *   password: 'postgres',
+ *   database: 'test',
+ *   max: 10
+ * })
+ *
+ * // Simple query
+ * const users = await pool.query`SELECT * FROM users WHERE id = ${1}`
+ *
+ * // Transaction
+ * const result = await pool.begin(async tx => {
+ *   await tx.query`INSERT INTO users ...`
+ *   return 'success'
+ * })
+ *
+ * // Manual acquire/release
+ * const conn = await pool.acquire()
+ * try {
+ *   await conn.query`SELECT 1`
+ * } finally {
+ *   pool.release(conn)
+ * }
+ *
+ * // Clean up
+ * await pool.close()
+ * ```
  */
 export declare class Pool {
-    private pool;
-    private enableLogs;
-    constructor(config: PoolConfig);
+    private _available;
+    private _config;
+    private _max;
+    private _total;
+    private _waiting;
+    private _isClosed;
+    private _checkClosed;
+    constructor(params: PoolParams);
     /**
-     * Executes a one-off query.
-     * Automatically acquires and releases a connection from the pool.
+     * Acquires a dedicated connection from the pool.
+     *
+     * **Note:** You must call `pool.release(conn)` manually when finished.
+     * For most cases, prefer using `pool.query()` or `pool.begin()` which handle this automatically.
+     *
+     * @returns A connection from the pool or a new one if available.
      *
      * @example
-     * const users = await pool.query<User>`SELECT * FROM users WHERE id = ${1}`;
+     * ```ts
+     * const conn = await pool.acquire()
+     * try {
+     *   await conn.query`SELECT 1`
+     * } finally {
+     *   pool.release(conn)
+     * }
+     * ```
      */
-    query<T extends QueryResultRow>(strings: TemplateStringsArray, ...values: any[]): Promise<T[]>;
+    acquire(): Promise<Connection>;
     /**
-     * Creates a reusable prepared statement.
-     * When executed via `stmt.execute()`, it automatically manages its own connection.
-     * Maps '?' placeholders to native PostgreSQL '$1, $2' indexes.
+     * Releases the connection back to the pool.
+     *
+     * If there are pending `acquire()` calls, the connection is passed directly to the next waiter.
+     * Otherwise, it's added to the available connections queue.
+     *
+     * @param conn - The connection to release.
      *
      * @example
-     * const stmt = await pool.prepare<User, [string]>('get_user', 'SELECT * FROM users WHERE email = ?');
-     * const users = await stmt.execute('test@example.com');
+     * ```ts
+     * const conn = await pool.acquire()
+     * try {
+     *   await conn.query`SELECT 1`
+     * } finally {
+     *   pool.release(conn)
+     * }
+     * ```
      */
-    prepare<TResult extends QueryResultRow, TParams extends any[] = []>(name: string, sqlTemplate: string): Promise<PreparedStatement<TResult, TParams>>;
+    release(conn: Connection): void;
     /**
-     * Acquires a dedicated connection from the pool.
-     * **Note:** You must call `connection.release()` manually when finished.
+     * Starts a managed transaction.
+     *
+     * Automatically acquires a connection and handles `BEGIN`, `COMMIT`, and `ROLLBACK`.
+     * If the callback throws an error, the transaction is rolled back.
+     *
+     * @param txCallback - Async function that receives a `Transaction` instance.
+     * @returns The value returned from the callback.
+     *
+     * @example
+     * ```ts
+     * const result = await pool.begin(async tx => {
+     *   await tx.query`INSERT INTO accounts (id, balance) VALUES (1, 100)`
+     *   await tx.query`UPDATE accounts SET balance = balance - 10 WHERE id = 1`
+     *   return { success: true }
+     * })
+     * ```
      */
-    acquire(): Promise<Connection>;
+    begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Promise<T>;
     /**
-     * Starts a managed transaction.
-     * Automatically acquires a connection and handles BEGIN/COMMIT/ROLLBACK.
+     * Executes a one-off query using pipeline.
+     *
+     * Automatically acquires and releases a connection from the pool.
+     * For optimal performance, multiple queries can be pipelined through the same connection.
+     *
+     * @param templates - Tagged template string with SQL.
+     * @param args - Query parameters.
+     * @returns Array of rows with proper typing.
      *
      * @example
-     * const result = await pool.begin(async (tx) => {
-     *   await tx.query`INSERT INTO accounts ...`;
-     *   return "success";
-     * });
+     * ```ts
+     * // Simple query
+     * const users = await pool.query`SELECT * FROM users`
+     *
+     * // With parameters
+     * const user = await pool.query`SELECT * FROM users WHERE id = ${1}`
+     *
+     * // With typed result
+     * type User = { id: number, name: string }
+     * const users = await pool.query<User>`SELECT * FROM users`
+     * ```
+     */
+    query<T extends Record<string, unknown>>(templates: TemplateStringsArray, ...args: any[]): Promise<T[]>;
+    /**
+     * Number of available (idle) connections in the pool.
      */
-    begin<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+    get size(): number;
     /**
-     * Returns current pool utilization statistics.
+     * Total number of connections currently managed by the pool
+     * (available + in use).
      */
-    get stats(): {
-        total: number;
-        idle: number;
-        waiting: number;
-    };
+    get total(): number;
     /**
      * Shuts down the pool and closes all active connections.
+     *
+     * All pending `acquire()` calls will be rejected with an error.
+     * The pool cannot be used after calling `close()`.
+     *
+     * @example
+     * ```ts
+     * await pool.close()
+     * ```
      */
     close(): Promise<void>;
 }
+export {};
 //# sourceMappingURL=pool.d.ts.map

package/dist/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,cAAc,EAAC,MAAM,IAAI,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C;;;GAGG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,UAAU,CAAS;gBAGvB,MAAM,EAAE,UAAU;IAMtB;;;;;;OAMG;IACU,KAAK,CAAC,CAAC,SAAS,cAAc,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAc5F;;;;;;;;OAQG;IACU,OAAO,CAAC,OAAO,SAAS,cAAc,EAAE,OAAO,SAAS,GAAG,EAAE,GAAG,EAAE,EAC3E,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAY/C;;;OAGG;IACU,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IAK3C;;;;;;;;;OASG;IACU,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAc5E;;OAEG;IACH,IAAW,KAAK;;;;MAMf;IAED;;OAEG;IACI,KAAK;CAGf"}
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAI3C,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAQ;IAEzB,OAAO,CAAC,YAAY;gBAIR,MAAM,EAAE,UAAU;IAM9B;;;;;;;;;;;;;;;;;OAiBG;IACG,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IA6BpC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYhF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAmCvG;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACG,KAAK;CAed"}

package/dist/pool.js

@@ -1,96 +1,245 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pool = void 0;
-const pg_1 = require("pg");
 const connection_1 = require("./connection");
-const prepared_statement_1 = require("./prepared.statement");
+const queue_1 = require("./queue");
 /**
  * The main entry point for Pgtx.
  * Manages a connection pool and provides high-level API for queries and transactions.
+ *
+ * @example
+ * ```ts
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   user: 'postgres',
+ *   password: 'postgres',
+ *   database: 'test',
+ *   max: 10
+ * })
+ *
+ * // Simple query
+ * const users = await pool.query`SELECT * FROM users WHERE id = ${1}`
+ *
+ * // Transaction
+ * const result = await pool.begin(async tx => {
+ *   await tx.query`INSERT INTO users ...`
+ *   return 'success'
+ * })
+ *
+ * // Manual acquire/release
+ * const conn = await pool.acquire()
+ * try {
+ *   await conn.query`SELECT 1`
+ * } finally {
+ *   pool.release(conn)
+ * }
+ *
+ * // Clean up
+ * await pool.close()
+ * ```
  */
 class Pool {
-    constructor(config) {
-        this.enableLogs = config.enableLogs ?? false;
-        this.pool = new pg_1.Pool(config);
+    _checkClosed() {
+        if (this._isClosed)
+            throw new Error('Pool closed');
+    }
+    constructor(params) {
+        this._available = new queue_1.Queue();
+        this._total = 0;
+        this._waiting = new queue_1.Queue();
+        this._isClosed = false;
+        this._config = params;
+        this._max = params.max || 20;
     }
     /**
-     * Executes a one-off query.
-     * Automatically acquires and releases a connection from the pool.
+     * Acquires a dedicated connection from the pool.
+     *
+     * **Note:** You must call `pool.release(conn)` manually when finished.
+     * For most cases, prefer using `pool.query()` or `pool.begin()` which handle this automatically.
+     *
+     * @returns A connection from the pool or a new one if available.
      *
      * @example
-     * const users = await pool.query<User>`SELECT * FROM users WHERE id = ${1}`;
+     * ```ts
+     * const conn = await pool.acquire()
+     * try {
+     *   await conn.query`SELECT 1`
+     * } finally {
+     *   pool.release(conn)
+     * }
+     * ```
      */
-    async query(strings, ...values) {
-        const conn = await this.acquire();
-        try {
-            return await conn.query(strings, ...values);
+    async acquire() {
+        this._checkClosed();
+        while (!this._available.isFree) {
+            const conn = this._available.get();
+            this._available.next();
+            if (conn.isAlive) {
+                return conn;
+            }
+            this._total--;
         }
-        catch (err) {
-            throw err;
-        }
-        finally {
-            conn.release();
+        if (this._total < this._max) {
+            this._total++;
+            try {
+                return await connection_1.Connection.new(this._config);
+            }
+            catch (err) {
+                this._total--;
+                throw err;
+            }
         }
+        return new Promise((resolve, reject) => {
+            this._waiting.push({ resolve, reject });
+        });
     }
     /**
-     * Creates a reusable prepared statement.
-     * When executed via `stmt.execute()`, it automatically manages its own connection.
-     * Maps '?' placeholders to native PostgreSQL '$1, $2' indexes.
+     * Releases the connection back to the pool.
+     *
+     * If there are pending `acquire()` calls, the connection is passed directly to the next waiter.
+     * Otherwise, it's added to the available connections queue.
+     *
+     * @param conn - The connection to release.
      *
      * @example
-     * const stmt = await pool.prepare<User, [string]>('get_user', 'SELECT * FROM users WHERE email = ?');
-     * const users = await stmt.execute('test@example.com');
-     */
-    async prepare(name, sqlTemplate) {
-        let index = 1;
-        const text = sqlTemplate.replace(/\?/g, () => `$${index++}`);
-        return new prepared_statement_1.PoolPreparedStatement(this.pool, text, name);
-    }
-    /**
-     * Acquires a dedicated connection from the pool.
-     * **Note:** You must call `connection.release()` manually when finished.
+     * ```ts
+     * const conn = await pool.acquire()
+     * try {
+     *   await conn.query`SELECT 1`
+     * } finally {
+     *   pool.release(conn)
+     * }
+     * ```
      */
-    async acquire() {
-        const client = await this.pool.connect();
-        return new connection_1.Connection(client, this.enableLogs);
+    release(conn) {
+        this._checkClosed();
+        if (!conn.isAlive) {
+            this._total--;
+            return;
+        }
+        if (!this._waiting.isFree) {
+            const waiter = this._waiting.get();
+            this._waiting.next();
+            waiter.resolve(conn);
+            return;
+        }
+        this._available.push(conn);
     }
     /**
      * Starts a managed transaction.
-     * Automatically acquires a connection and handles BEGIN/COMMIT/ROLLBACK.
+     *
+     * Automatically acquires a connection and handles `BEGIN`, `COMMIT`, and `ROLLBACK`.
+     * If the callback throws an error, the transaction is rolled back.
+     *
+     * @param txCallback - Async function that receives a `Transaction` instance.
+     * @returns The value returned from the callback.
      *
      * @example
-     * const result = await pool.begin(async (tx) => {
-     *   await tx.query`INSERT INTO accounts ...`;
-     *   return "success";
-     * });
+     * ```ts
+     * const result = await pool.begin(async tx => {
+     *   await tx.query`INSERT INTO accounts (id, balance) VALUES (1, 100)`
+     *   await tx.query`UPDATE accounts SET balance = balance - 10 WHERE id = 1`
+     *   return { success: true }
+     * })
+     * ```
      */
-    async begin(callback) {
+    async begin(txCallback) {
+        this._checkClosed();
         const conn = await this.acquire();
         try {
-            return await conn.begin(callback);
-        }
-        catch (err) {
-            throw err;
+            return conn.begin(txCallback);
         }
         finally {
-            conn.release();
+            this.release(conn);
         }
     }
     /**
-     * Returns current pool utilization statistics.
+     * Executes a one-off query using pipeline.
+     *
+     * Automatically acquires and releases a connection from the pool.
+     * For optimal performance, multiple queries can be pipelined through the same connection.
+     *
+     * @param templates - Tagged template string with SQL.
+     * @param args - Query parameters.
+     * @returns Array of rows with proper typing.
+     *
+     * @example
+     * ```ts
+     * // Simple query
+     * const users = await pool.query`SELECT * FROM users`
+     *
+     * // With parameters
+     * const user = await pool.query`SELECT * FROM users WHERE id = ${1}`
+     *
+     * // With typed result
+     * type User = { id: number, name: string }
+     * const users = await pool.query<User>`SELECT * FROM users`
+     * ```
      */
-    get stats() {
-        return {
-            total: this.pool.totalCount,
-            idle: this.pool.idleCount,
-            waiting: this.pool.waitingCount
-        };
+    query(templates, ...args) {
+        this._checkClosed();
+        while (!this._available.isFree) {
+            const conn = this._available.get();
+            if (conn.isAlive) {
+                return conn.query(templates, ...args);
+            }
+            this._available.next();
+            this._total--;
+        }
+        if (this._total < this._max) {
+            this._total++;
+            return connection_1.Connection.new(this._config)
+                .catch(err => {
+                this._total--;
+                throw err;
+            })
+                .then(conn => {
+                this.release(conn);
+                return conn.query(templates, ...args);
+            });
+        }
+        return this.acquire()
+            .then(conn => {
+            this.release(conn);
+            return conn.query(templates, ...args);
+        });
+    }
+    /**
+     * Number of available (idle) connections in the pool.
+     */
+    get size() {
+        return this._available.size;
+    }
+    /**
+     * Total number of connections currently managed by the pool
+     * (available + in use).
+     */
+    get total() {
+        return this._total;
     }
     /**
      * Shuts down the pool and closes all active connections.
+     *
+     * All pending `acquire()` calls will be rejected with an error.
+     * The pool cannot be used after calling `close()`.
+     *
+     * @example
+     * ```ts
+     * await pool.close()
+     * ```
      */
-    close() {
-        return this.pool.end();
+    async close() {
+        while (!this._available.isFree) {
+            const conn = this._available.get();
+            this._available.next();
+            conn.close();
+        }
+        while (!this._waiting.isFree) {
+            const waiter = this._waiting.get();
+            this._waiting.next();
+            waiter.reject(new Error('Pool closed'));
+        }
+        this._total = 0;
     }
 }
 exports.Pool = Pool;

package/dist/protocol/connection-request-writer.d.ts

@@ -0,0 +1,38 @@
+import { RequestType } from "./constants";
+export declare class ConnectionRequestBuffer {
+    private buffer;
+    private offset;
+    private lastRequestLenByteOffset;
+    private constructor();
+    static new(capacity: number): ConnectionRequestBuffer;
+    private ensureCapacity;
+    writeCString(string: string): this;
+    writeString(string: string): this;
+    writeInt32(number: number): this;
+    writeInt16(number: number): this;
+    writeChar(char: string): this;
+    startRequest(requestType: RequestType): this;
+    startMessage(): this;
+    endRequest(): this;
+    asBuffer(): Buffer<ArrayBufferLike>;
+    clear(): void;
+}
+export declare class ConnectionRequestWriter {
+    private buffer;
+    private constructor();
+    static new(): ConnectionRequestWriter;
+    writeQuery(text: string): this;
+    writeParse(name: string | "", text: string): this;
+    writeDescribe(statementName: string | ""): this;
+    writeBind(portName: string | "", statementName: string | "", params: (string | null)[]): this;
+    writeClose(name: string): this;
+    writeStartup(user: string, database: string): this;
+    writeExecute(portName: string | ""): this;
+    writeSync(): this;
+    writePassword(password: string): this;
+    writeSaslInitial(mechanism: string, clientFirstMessage: string): this;
+    writeSaslResponse(clientFinalMessage: string): this;
+    asBuffer(): Buffer<ArrayBufferLike>;
+    clear(): this;
+}
+//# sourceMappingURL=connection-request-writer.d.ts.map

package/dist/protocol/connection-request-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-request-writer.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-request-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAA;AAGvD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,wBAAwB;IAHpC,OAAO;IAOP,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM;IAK3B,OAAO,CAAC,cAAc;IAmBtB,YAAY,CAAC,MAAM,EAAE,MAAM;IAY3B,WAAW,CAAC,MAAM,EAAE,MAAM;IAS1B,UAAU,CAAC,MAAM,EAAE,MAAM;IAUzB,UAAU,CAAC,MAAM,EAAE,MAAM;IAUzB,SAAS,CAAC,IAAI,EAAE,MAAM;IAStB,YAAY,CAAC,WAAW,EAAE,WAAW;IAQrC,YAAY;IAMZ,UAAU;IAUV,QAAQ;IAKR,KAAK;CAIR;AAGD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,MAAM;IADlB,OAAO;IAIP,MAAM,CAAC,GAAG;IAMV,UAAU,CAAC,IAAI,EAAE,MAAM;IASvB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM;IAW1C,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,EAAE;IAUxC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IAmBtF,UAAU,CAAC,IAAI,EAAE,MAAM;IAUvB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAY3C,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE;IAUlC,SAAS;IAOT,aAAa,CAAC,QAAQ,EAAE,MAAM;IAS9B,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM;IAW9D,iBAAiB,CAAC,kBAAkB,EAAE,MAAM;IAS5C,QAAQ;IAKR,KAAK;CAKR"}