@m2k-5f/pgtx 1.4.12 → 2.0.0

package/dist/clauses/update.clause.js

@@ -18,7 +18,7 @@ class UpdateClause extends abstract_clause_1.Clause {
             if (index)
                 params.text.push(', ');
             params.args.push(value);
-            params.text.push(`${key} = $${params.counter++}`);
+            params.text.push(`${key} = $${params.args.length}`);
         });
     }
 }

package/dist/clauses/where.clause.d.ts

@@ -2,7 +2,7 @@ import { Clause } from "./abstract.clause";
 import { ClauseStrategyParams } from "../types";
 export declare class WhereClause<T extends Record<string, any>> extends Clause {
     private _value;
-    constructor(_value: T);
+    private constructor();
     static create<T extends Record<string, any>>(whereMap: T): WhereClause<T>;
     mapIntoQuery(params: ClauseStrategyParams): void;
 }

package/dist/clauses/where.clause.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"where.clause.d.ts","sourceRoot":"","sources":["../../src/clauses/where.clause.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAE,SAAQ,MAAM;IAE9D,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,CAAC;WAGP,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC;IAItD,YAAY,CAAC,MAAM,EAAE,oBAAoB;CAYrD"}
+{"version":3,"file":"where.clause.d.ts","sourceRoot":"","sources":["../../src/clauses/where.clause.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAE,SAAQ,MAAM;IAE9D,OAAO,CAAC,MAAM;IADlB,OAAO;WAIO,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC;IAItD,YAAY,CAAC,MAAM,EAAE,oBAAoB;CAYrD"}

package/dist/clauses/where.clause.js

@@ -18,7 +18,7 @@ class WhereClause extends abstract_clause_1.Clause {
             if (index)
                 params.text.push(' AND ');
             params.args.push(value);
-            params.text.push(`${key} = $${params.counter++}`);
+            params.text.push(`"${key}" = $${params.args.length}`);
         });
     }
 }

package/dist/connection.d.ts

@@ -1,51 +1,155 @@
-import { PoolClient, QueryResultRow } from "pg";
-import { PreparedStatement } from "./types";
+import { ColumnDescription } from "./types";
 import { Transaction } from "./transaction";
+import { Queue } from "./queue";
+type LogLevel = "none" | "error" | "notice" | "query";
+export type ConnectionParams = {
+    user: string;
+    password?: string;
+    host: string;
+    port: number;
+    database: string;
+    logLevel?: LogLevel;
+};
+export type ConnectionQueryContext = {
+    columns: ColumnDescription[];
+    rows: (string | null)[][];
+    resolve: (value: any) => void;
+    reject: (err: Error) => void;
+    text: string;
+    statementName: string | null;
+};
+export declare class ConnectionQueryQueue extends Queue<ConnectionQueryContext> {
+    rejectAllNext(error: Error): void;
+}
 /**
- * Represents a single dedicated connection to the database.
- * Always remember to call `.release()` when finished.
+ * Represents a single dedicated connection to the PostgreSQL database.
+ *
+ * Supports:
+ * - Tagged template queries with automatic parameter binding
+ * - Prepared statements with caching
+ * - Transaction management with savepoints
+ * - Pipeline execution for concurrent queries
+ *
+ * @example
+ * ```ts
+ * const conn = await Connection.new({
+ *   host: 'localhost',
+ *   user: 'postgres',
+ *   password: 'postgres',
+ *   database: 'test'
+ * })
+ *
+ * // Simple query
+ * const users = await conn.query`SELECT * FROM users WHERE id = ${1}`
+ *
+ * // Transaction
+ * await conn.begin(async tx => {
+ *   await tx.query`INSERT INTO users ...`
+ * })
+ *
+ * // Close connection
+ * conn.close()
+ * ```
  */
 export declare class Connection {
-    private readonly client;
-    private readonly enableLogs;
-    private isReleased;
-    constructor(client: PoolClient, enableLogs: boolean);
-    /**
-     * Checks if the connection is still open and not returned to the pool.
-     */
-    get isActive(): boolean;
+    private _isFlushing;
+    private _isAlive;
+    private _socket;
+    private _writer;
+    private _queue;
+    private _statementDescriptions;
+    private _statements;
+    private _parsePending;
+    private _stmtCounter;
+    private _logLevel;
+    private _nextStatement;
+    private constructor();
     /**
-     * Creates a prepared statement on this specific connection.
-     * Maps '?' placeholders to native PostgreSQL '$1, $2' indexes.
+     * Creates a new database connection.
+     *
+     * @param params - Connection parameters
+     * @returns A new Connection instance
+     * @throws {Error} If authentication fails or connection cannot be established
      *
      * @example
-     * const stmt = await conn.prepare('get_user', 'SELECT * FROM users WHERE id = ?');
-     * const rows = await stmt.execute(1);
+     * ```ts
+     * const conn = await Connection.new({
+     *   host: 'localhost',
+     *   port: 5432,
+     *   user: 'postgres',
+     *   password: 'secret',
+     *   database: 'myapp'
+     * })
+     * ```
      */
-    prepare<TResult extends QueryResultRow, TParams extends any[] = []>(name: string, sqlTemplate: string): Promise<PreparedStatement<TResult, TParams>>;
+    static new(params: ConnectionParams): Promise<Connection>;
     /**
-     * Releases the connection back to the pool.
-     * The connection cannot be used after this call.
+     * Executes a query using tagged template literals.
+     *
+     * Parameters are automatically bound to `$1, $2, ...` placeholders.
+     * Queries with parameters use prepared statements for performance.
+     *
+     * @param templates - Tagged template string with SQL
+     * @param args - Query parameters
+     * @returns Array of rows with proper typing
+     * @throws {Error} If connection is dead or query fails
+     *
+     * @example
+     * ```ts
+     * // Simple query
+     * const users = await conn.query`SELECT * FROM users`
+     *
+     * // With parameters
+     * const user = await conn.query`SELECT * FROM users WHERE id = ${1}`
+     *
+     * // With typed result
+     * type User = { id: number, name: string }
+     * const users = await conn.query<User>`SELECT * FROM users`
+     * ```
      */
-    release(): Promise<void>;
-    private checkActive;
+    query<T extends Record<string, unknown>>(templates: TemplateStringsArray, ...args: any[]): Promise<T[]>;
     /**
-     * Executes a tagged SQL query using structural caching.
-     * Supports recursive fragments and clauses.
+     * Starts a managed transaction on this connection.
+     *
+     * Automatically handles:
+     * - `BEGIN` before the callback
+     * - `COMMIT` on successful completion
+     * - `ROLLBACK` if an error is thrown
+     *
+     * @param txCallback - Async function that receives a `Transaction` instance
+     * @returns The value returned from the callback
+     * @throws {Error} If connection is dead or transaction fails
      *
      * @example
-     * const users = await conn.query`SELECT * FROM users WHERE id = ${1}`;
+     * ```ts
+     * const result = await conn.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 }
+     * })
+     * ```
      */
-    query<T extends QueryResultRow = any>(strings: TemplateStringsArray, ...values: any[]): Promise<T[]>;
+    begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Promise<T>;
+    private _registerFlush;
+    private _flush;
+    private _handlePacket;
+    private _handleError;
     /**
-     * Starts a managed transaction on this connection.
-     * Handles automatic COMMIT on success or ROLLBACK on error.
+     * Checks if the connection is still alive and usable.
+     * Returns `false` if the socket is destroyed or connection is dead.
+     */
+    get isAlive(): boolean;
+    /**
+     * Closes the connection immediately.
+     * All pending queries will be rejected with an error.
+     * The connection cannot be used after this call.
      *
      * @example
-     * await conn.begin(async (tx) => {
-     *   await tx.query`INSERT INTO logs ...`;
-     * });
+     * ```ts
+     * conn.close()
+     * ```
      */
-    begin<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+    close(): void;
 }
+export {};
 //# sourceMappingURL=connection.d.ts.map

package/dist/connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,IAAI,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAM3C;;;GAGG;AACH,qBAAa,UAAU;IAIf,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJ/B,OAAO,CAAC,UAAU,CAAiB;gBAGd,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,OAAO;IAGxC;;OAEG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAED;;;;;;;OAOG;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,IAAI,CAAC;IAMrC,OAAO,CAAC,WAAW;IAMnB;;;;;;OAMG;IACU,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,GAAG,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAkBjH;;;;;;;;OAQG;IACU,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAmB/E"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B,KAAK,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACtB,CAAA;AAKD,MAAM,MAAM,sBAAsB,GAAG;IACjC,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,CAAA;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IAC7B,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B,CAAA;AAGD,qBAAa,oBAAqB,SAAQ,KAAK,CAAC,sBAAsB,CAAC;IAEnE,aAAa,CAAC,KAAK,EAAE,KAAK;CAM7B;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,sBAAsB,CAAyC;IACvE,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,SAAS,CAAU;IAG3B,OAAO,CAAC,cAAc;IAItB,OAAO;IAcP;;;;;;;;;;;;;;;;;OAiBG;WACU,GAAG,CAAC,MAAM,EAAE,gBAAgB;IAQzC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;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;IA0DvG;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAqBhF,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,MAAM;IAkBd,OAAO,CAAC,aAAa;IAoFrB,OAAO,CAAC,YAAY;IAQpB;;;OAGG;IACH,IAAI,OAAO,YAEV;IAGD;;;;;;;;;OASG;IACH,KAAK;CAIR"}

package/dist/connection.js

@@ -1,89 +1,188 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = void 0;
+exports.Connection = exports.ConnectionQueryQueue = void 0;
+const process_1 = require("process");
+const connection_request_writer_1 = require("./protocol/connection-request-writer");
+const socket_authorization_1 = require("./protocol/socket-authorization");
+const constants_1 = require("./protocol/constants");
+const value_parser_1 = require("./utils/value-parser");
+const template_compiler_1 = require("./utils/template-compiler");
 const transaction_1 = require("./transaction");
-const query_cacher_1 = require("./query.cacher");
-const prepared_statement_1 = require("./prepared.statement");
-const cacher = new query_cacher_1.QueryCacher();
+const socket_connector_1 = require("./protocol/socket-connector");
+const queue_1 = require("./queue");
+const ErrConnectionDead = new Error("Connection is Dead");
+class ConnectionQueryQueue extends queue_1.Queue {
+    rejectAllNext(error) {
+        while (!this.isFree) {
+            this.get().reject(error);
+            this.next();
+        }
+    }
+}
+exports.ConnectionQueryQueue = ConnectionQueryQueue;
 /**
- * Represents a single dedicated connection to the database.
- * Always remember to call `.release()` when finished.
+ * Represents a single dedicated connection to the PostgreSQL database.
+ *
+ * Supports:
+ * - Tagged template queries with automatic parameter binding
+ * - Prepared statements with caching
+ * - Transaction management with savepoints
+ * - Pipeline execution for concurrent queries
+ *
+ * @example
+ * ```ts
+ * const conn = await Connection.new({
+ *   host: 'localhost',
+ *   user: 'postgres',
+ *   password: 'postgres',
+ *   database: 'test'
+ * })
+ *
+ * // Simple query
+ * const users = await conn.query`SELECT * FROM users WHERE id = ${1}`
+ *
+ * // Transaction
+ * await conn.begin(async tx => {
+ *   await tx.query`INSERT INTO users ...`
+ * })
+ *
+ * // Close connection
+ * conn.close()
+ * ```
  */
 class Connection {
-    constructor(client, enableLogs) {
-        this.client = client;
-        this.enableLogs = enableLogs;
-        this.isReleased = false;
+    _nextStatement() {
+        return `s-${this._stmtCounter++}`;
     }
-    /**
-     * Checks if the connection is still open and not returned to the pool.
-     */
-    get isActive() {
-        return !this.isReleased;
+    constructor(socket, writer, logLevel) {
+        this._isFlushing = false;
+        this._isAlive = true;
+        this._queue = new ConnectionQueryQueue();
+        this._statementDescriptions = new Map();
+        this._statements = new Map();
+        this._parsePending = new Map();
+        this._stmtCounter = 0;
+        this._logLevel = logLevel;
+        this._socket = new socket_connector_1.SocketConnector(socket, (type, reader) => this._handlePacket(type, reader), error => this._handleError(error));
+        this._writer = writer;
     }
     /**
-     * Creates a prepared statement on this specific connection.
-     * Maps '?' placeholders to native PostgreSQL '$1, $2' indexes.
+     * Creates a new database connection.
+     *
+     * @param params - Connection parameters
+     * @returns A new Connection instance
+     * @throws {Error} If authentication fails or connection cannot be established
      *
      * @example
-     * const stmt = await conn.prepare('get_user', 'SELECT * FROM users WHERE id = ?');
-     * const rows = await stmt.execute(1);
+     * ```ts
+     * const conn = await Connection.new({
+     *   host: 'localhost',
+     *   port: 5432,
+     *   user: 'postgres',
+     *   password: 'secret',
+     *   database: 'myapp'
+     * })
+     * ```
      */
-    async prepare(name, sqlTemplate) {
-        let index = 1;
-        const text = sqlTemplate.replace(/\?/g, () => `$${index++}`);
-        return new prepared_statement_1.ConnPraparedStatement(this.client, text, name);
+    static async new(params) {
+        const writer = connection_request_writer_1.ConnectionRequestWriter.new();
+        const socket = await (0, socket_authorization_1.createAuthorizedSocket)(writer, params);
+        return new Connection(socket, writer, params.logLevel || 'error');
     }
     /**
-     * Releases the connection back to the pool.
-     * The connection cannot be used after this call.
-     */
-    async release() {
-        if (this.isReleased)
-            return;
-        this.isReleased = true;
-        this.client.release();
-    }
-    checkActive() {
-        if (this.isReleased) {
-            throw new Error("Connection has been released");
-        }
-    }
-    /**
-     * Executes a tagged SQL query using structural caching.
-     * Supports recursive fragments and clauses.
+     * Executes a query using tagged template literals.
+     *
+     * Parameters are automatically bound to `$1, $2, ...` placeholders.
+     * Queries with parameters use prepared statements for performance.
+     *
+     * @param templates - Tagged template string with SQL
+     * @param args - Query parameters
+     * @returns Array of rows with proper typing
+     * @throws {Error} If connection is dead or query fails
      *
      * @example
-     * const users = await conn.query`SELECT * FROM users WHERE id = ${1}`;
+     * ```ts
+     * // Simple query
+     * const users = await conn.query`SELECT * FROM users`
+     *
+     * // With parameters
+     * const user = await conn.query`SELECT * FROM users WHERE id = ${1}`
+     *
+     * // With typed result
+     * type User = { id: number, name: string }
+     * const users = await conn.query<User>`SELECT * FROM users`
+     * ```
      */
-    async query(strings, ...values) {
-        this.checkActive();
-        const { text, args } = cacher.cachedBuild({
-            templates: strings,
-            args: values,
-            counter: 1
-        });
-        if (this.enableLogs) {
-            console.log(`\nQUERY:     ${text}\n${args.length ? `ARGUMENTS: [${args}]\n` : ""}`);
+    query(templates, ...args) {
+        if (!this._isAlive)
+            throw ErrConnectionDead;
+        const query = (0, template_compiler_1.compileSqlTemplate)({ templates, args });
+        if (this._logLevel === 'query') {
+            console.log(`\nQUERY:     ${query.text}\n${query.args.length !== 0 ? `ARGUMENTS: [${query.args}]\n` : ""}`);
         }
-        const result = await this.client.query(text, args);
-        return result.rows;
+        return new Promise((resolve, reject) => {
+            this._registerFlush();
+            if (query.args.length === 0) {
+                this._writer.writeQuery(query.text);
+                this._queue.push({
+                    resolve, reject, columns: [], rows: [], statementName: null, text: query.text
+                });
+            }
+            else {
+                let rejectParsed = reject;
+                let statementName = '';
+                if (!this._statements.has(query.text) && !this._parsePending.has(query.text)) {
+                    statementName = this._nextStatement();
+                    this._parsePending.set(query.text, statementName);
+                    rejectParsed = (error) => {
+                        this._parsePending.delete(query.text);
+                        reject(error);
+                    };
+                    this._writer
+                        .writeParse(statementName, query.text);
+                    console.log('parsed once', statementName, query.text);
+                }
+                statementName = this._statements.get(query.text) || this._parsePending.get(query.text);
+                if (!this._statementDescriptions.has(statementName)) {
+                    this._writer.writeDescribe(statementName);
+                }
+                this._queue.push({
+                    resolve, reject: rejectParsed, columns: [], rows: [], statementName: statementName, text: query.text
+                });
+                this._writer
+                    .writeBind("", statementName, query.args)
+                    .writeExecute("");
+            }
+        });
     }
     /**
      * Starts a managed transaction on this connection.
-     * Handles automatic COMMIT on success or ROLLBACK on error.
+     *
+     * Automatically handles:
+     * - `BEGIN` before the callback
+     * - `COMMIT` on successful completion
+     * - `ROLLBACK` if an error is thrown
+     *
+     * @param txCallback - Async function that receives a `Transaction` instance
+     * @returns The value returned from the callback
+     * @throws {Error} If connection is dead or transaction fails
      *
      * @example
-     * await conn.begin(async (tx) => {
-     *   await tx.query`INSERT INTO logs ...`;
-     * });
+     * ```ts
+     * const result = await conn.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) {
-        this.checkActive();
+    async begin(txCallback) {
+        if (!this._isAlive)
+            throw ErrConnectionDead;
         const tx = new transaction_1.Transaction(this);
         try {
             await tx.query `BEGIN`;
-            const result = await callback(tx);
+            const result = await txCallback(tx);
             if (tx.isActive)
                 await tx.commit();
             return result;
@@ -94,5 +193,137 @@ class Connection {
             throw err;
         }
     }
+    _registerFlush() {
+        if (!this._isFlushing) {
+            this._isFlushing = true;
+            (0, process_1.nextTick)(() => this._flush());
+        }
+    }
+    _flush() {
+        if (!this._isAlive) {
+            this._queue.rejectAllNext(ErrConnectionDead);
+            return;
+        }
+        try {
+            this._socket.write(this._writer.writeSync());
+            this._writer.clear();
+        }
+        catch (err) {
+            this._isAlive = false;
+            this._socket.destroy();
+            this._queue.rejectAllNext(ErrConnectionDead);
+        }
+    }
+    _handlePacket(type, reader) {
+        const context = this._queue.get();
+        switch (type) {
+            case constants_1.ResponseTypes.ParseComplete:
+                {
+                    reader.readParseComplete();
+                    this._statements.set(context.text, context.statementName);
+                    this._parsePending.delete(context.text);
+                }
+                break;
+            case constants_1.ResponseTypes.BindComplete:
+                {
+                    reader.readBindComplete();
+                }
+                break;
+            case constants_1.ResponseTypes.CloseComplete:
+                {
+                    reader.readBindComplete();
+                }
+                break;
+            case constants_1.ResponseTypes.ParameterDescription:
+                {
+                    reader.readParameterDescription();
+                }
+                break;
+            case constants_1.ResponseTypes.NoData:
+                {
+                    reader.readNoData();
+                    if (context.statementName) {
+                        this._statementDescriptions.set(context.statementName, []);
+                    }
+                }
+                break;
+            case constants_1.ResponseTypes.RowDescription:
+                {
+                    if (context.statementName) {
+                        this._statementDescriptions.set(context.statementName, reader.readRowDescription());
+                    }
+                    else {
+                        context.columns = reader.readRowDescription();
+                    }
+                }
+                break;
+            case constants_1.ResponseTypes.DataRow:
+                {
+                    context.rows.push(reader.readDataRow());
+                }
+                break;
+            case constants_1.ResponseTypes.ComandComplete:
+                {
+                    reader.readCommandComplete();
+                    if (context.statementName) {
+                        context.columns = this._statementDescriptions.get(context.statementName);
+                    }
+                    context.resolve((0, value_parser_1.parseRowValues)(context.columns, context.rows));
+                    this._queue.next();
+                }
+                break;
+            case constants_1.ResponseTypes.ErrorResponse:
+                {
+                    const message = reader.readErrorResponse();
+                    if (this._logLevel === 'error' || this._logLevel === 'notice' || this._logLevel === 'query') {
+                        console.log(`\nError:    ${message}\n`);
+                    }
+                    const error = new Error(message);
+                    this._queue.rejectAllNext(error);
+                }
+                break;
+            case constants_1.ResponseTypes.ReadyForQuery:
+                {
+                    this._isFlushing = false;
+                    reader.readReadyForQuery();
+                }
+                break;
+            case constants_1.ResponseTypes.Notice:
+                {
+                    const message = reader.readErrorResponse();
+                    if (this._logLevel === 'notice' || this._logLevel === 'query') {
+                        console.log(`\nError:    ${message}\n`);
+                    }
+                }
+                break;
+            default: console.warn('Undeclared response type: ', type);
+        }
+    }
+    _handleError(error) {
+        this._isAlive = false;
+        this._queue.rejectAllNext(error);
+        this._socket.destroy();
+    }
+    /**
+     * Checks if the connection is still alive and usable.
+     * Returns `false` if the socket is destroyed or connection is dead.
+     */
+    get isAlive() {
+        return this._isAlive && !this._socket.isDestroyed;
+    }
+    /**
+     * Closes the connection immediately.
+     * All pending queries will be rejected with an error.
+     * The connection cannot be used after this call.
+     *
+     * @example
+     * ```ts
+     * conn.close()
+     * ```
+     */
+    close() {
+        this._isAlive = false;
+        this._socket.destroy();
+    }
 }
 exports.Connection = Connection;

package/dist/index.d.ts

@@ -1,13 +1,5 @@
 import { Pool as PgtxPool } from "./pool";
-import { EmptyClause } from "./clauses/empty.clause";
-import { WhereClause } from "./clauses/where.clause";
-import { InsertClause } from "./clauses/insert.clause";
-import { UpdateClause } from "./clauses/update.clause";
-import { ExcludeUpdateClause } from "./clauses/exclude.clause";
-import { IdentifierClause } from "./clauses/iden.caluse";
-import { LiteralClause } from "./clauses/literal.clause";
-import { FragmentClause } from "./clauses/fragment.clause";
-import { ArrayClause } from "./clauses/array.clause";
+import { IdentifierClause, InsertClause, ArrayClause, UpdateClause, ExcludeUpdateClause, WhereClause, LiteralClause, FragmentClause } from './clauses';
 import { Connection } from "./connection";
 import { Transaction } from "./transaction";
 /**
@@ -53,7 +45,7 @@ export declare const sql: {
      * sql`SELECT * FROM users ${filters.length ? sql.fragment`WHERE ...` : sql.empty}`
      * // Result: SELECT * FROM users
      */
-    empty: EmptyClause;
+    empty: import("./clauses").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.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EAAe,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,GAAG;IACZ;;;;;;;;;;;OAWG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;KAWC;;IAGD;;;;;;;;;;OAUG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;CAEN,CAAA;AAGD;;;GAGG;AAEH,OAAO,EAAC,UAAU,IAAI,UAAU,EAAC,CAAA;AAEjC,OAAO,EAAC,WAAW,IAAI,WAAW,EAAC,CAAA;AAEnC,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EACH,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,mBAAmB,EAEnB,WAAW,EACX,aAAa,EACb,cAAc,EACjB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,GAAG;IACZ;;;;;;;;;;;OAWG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;KAWC;;IAGD;;;;;;;;;;OAUG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;CAEN,CAAA;AAGD;;;GAGG;AAEH,OAAO,EAAE,UAAU,IAAI,UAAU,EAAE,CAAA;AAEnC,OAAO,EAAE,WAAW,IAAI,WAAW,EAAE,CAAA;AAErC,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAA"}