postgrejs 2.22.9 → 2.23.0

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 ## Changelog
 
-### [v2.22.9](https://github.com/panates/postgrejs/compare/v2.22.8...v2.22.9) - 
+### [v2.23.0](https://github.com/panates/postgrejs/compare/v2.22.9...v2.23.0) - 
+
+#### 🛠 Refactoring and Updates
+
+- dev: Updated deps to support latest TypeScript and NodeJS. @Eray Hanoğlu 
+- dev: Updated deps to support latest TypeScript and NodeJS. @Eray Hanoğlu 
+
+### [v2.22.9](https://github.com/panates/postgrejs/compare/v2.22.8...v2.22.9) -  4 December 2025 
 
 ### [v2.22.8](https://github.com/panates/postgrejs/compare/v2.22.7...v2.22.8) -  27 October 2025 
 

package/{esm/connection → connection}/bind-param.js

@@ -1,4 +1,6 @@
 export class BindParam {
+    oid;
+    value;
     constructor(oid, value) {
         this.oid = oid;
         this.value = value;

package/{esm/connection → connection}/connection.js

@@ -5,10 +5,12 @@ import { BindParam } from './bind-param.js';
 import { IntlConnection } from './intl-connection.js';
 import { PreparedStatement } from './prepared-statement.js';
 export class Connection extends SafeEventEmitter {
+    _pool;
+    _intlCon;
+    _notificationListeners = new SafeEventEmitter();
+    _closing = false;
     constructor(arg0, arg1) {
         super();
-        this._notificationListeners = new SafeEventEmitter();
-        this._closing = false;
         if (arg0 &&
             typeof arg0 === 'object' &&
             typeof arg0.acquire === 'function') {

package/{esm/connection → connection}/cursor.js

@@ -4,11 +4,16 @@ import { SafeEventEmitter } from '../safe-event-emitter.js';
 import { convertRowToObject } from '../util/convert-row-to-object.js';
 import { parseRow } from '../util/parse-row.js';
 export class Cursor extends SafeEventEmitter {
+    _statement;
+    _portal;
+    _parsers;
+    _queryOptions;
+    _taskQueue = new TaskQueue({ concurrency: 1 });
+    _rows = new DoublyLinked();
+    _closed = false;
+    fields;
     constructor(statement, portal, fields, parsers, queryOptions) {
         super();
-        this._taskQueue = new TaskQueue({ concurrency: 1 });
-        this._rows = new DoublyLinked();
-        this._closed = false;
         this._statement = statement;
         this._portal = portal;
         this._parsers = parsers;

package/{esm/connection → connection}/intl-connection.js

@@ -13,11 +13,14 @@ import { parseRow } from '../util/parse-row.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
 const DataFormat = Protocol.DataFormat;
 export class IntlConnection extends SafeEventEmitter {
+    _refCount = 0;
+    _config;
+    _onErrorSavePoint;
+    transactionStatus = 'I';
+    socket;
+    statementQueue = new TaskQueue({ concurrency: 1 });
     constructor(config) {
         super();
-        this._refCount = 0;
-        this.transactionStatus = 'I';
-        this.statementQueue = new TaskQueue({ concurrency: 1 });
         this._config = Object.freeze(getConnectionConfig(config));
         this.socket = new PgSocket(this._config);
         this.socket.on('error', err => this._onError(err));

package/{esm/connection → connection}/pool.js

@@ -6,9 +6,12 @@ import { getConnectionConfig } from '../util/connection-config.js';
 import { Connection } from './connection.js';
 import { getIntlConnection, IntlConnection } from './intl-connection.js';
 export class Pool extends SafeEventEmitter {
+    _pool;
+    _notificationListeners = new SafeEventEmitter();
+    _notificationConnection;
+    config;
     constructor(config) {
         super();
-        this._notificationListeners = new SafeEventEmitter();
         const cfg = getConnectionConfig(config);
         this.config = Object.freeze(cfg);
         const poolOptions = {};

package/{esm/connection → connection}/portal.js

@@ -3,8 +3,10 @@ import { GlobalTypeMap } from '../data-type-map.js';
 import { Protocol } from '../protocol/protocol.js';
 import { getIntlConnection } from './intl-connection.js';
 export class Portal {
+    _statement;
+    _name;
+    _columnFormat = DEFAULT_COLUMN_FORMAT;
     constructor(statement, name) {
-        this._columnFormat = DEFAULT_COLUMN_FORMAT;
         this._statement = statement;
         this._name = name;
     }

package/{esm/connection → connection}/prepared-statement.js

@@ -13,11 +13,14 @@ import { Portal } from './portal.js';
 let statementCounter = 0;
 let portalCounter = 0;
 export class PreparedStatement extends SafeEventEmitter {
+    _connection;
+    _sql = '';
+    _name = '';
+    _paramTypes;
+    _onErrorSavePoint;
+    _refCount = 0;
     constructor(connection, sql, paramTypes) {
         super();
-        this._sql = '';
-        this._name = '';
-        this._refCount = 0;
         this._connection = connection;
         this._name = 'S_' + ++statementCounter;
         this._sql = sql;

package/{esm/constants.js → constants.js}

@@ -1,7 +1,7 @@
 import { Protocol } from './protocol/protocol.js';
 var DataFormat = Protocol.DataFormat;
 // @ts-ignore
-Symbol.asyncDispose ?? (Symbol.asyncDispose = Symbol('Symbol.asyncDispose'));
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
 export { DataFormat };
 export const DEFAULT_COLUMN_FORMAT = DataFormat.binary;
 export var ConnectionState;

package/{esm/data-type-map.js → data-type-map.js}

@@ -23,9 +23,9 @@ import { ArrayTimestamptzType, TimestamptzType, } from './data-types/timestamptz
 import { ArrayUuidType, UuidType } from './data-types/uuid-type.js';
 import { ArrayVarcharType, VarcharType } from './data-types/varchar-type.js';
 export class DataTypeMap {
+    _itemsByOID = {};
+    _items = [];
     constructor(other) {
-        this._itemsByOID = {};
-        this._items = [];
         if (other instanceof DataTypeMap)
             Object.assign(this._items, other._items);
     }

package/package.json

@@ -1,37 +1,32 @@
 {
   "name": "postgrejs",
   "description": "Professional PostgreSQL client NodeJS",
-  "version": "2.22.9",
+  "version": "2.23.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
-    "@jsopen/objects": "^2.0.2",
+    "@jsopen/objects": "^2.2.0",
     "doublylinked": "^2.5.6",
     "lightning-pool": "^4.12.0",
     "postgres-bytea": "^3.0.0",
-    "power-tasks": "^1.11.1",
+    "power-tasks": "^1.14.2",
     "putil-promisify": "^1.10.1",
-    "putil-varhelpers": "^1.6.5",
+    "putil-varhelpers": "^1.7.0",
     "tslib": "^2.8.1"
   },
   "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": {
-        "types": "./types/index.d.cts",
-        "default": "./cjs/index.js"
-      },
-      "default": "./esm/index.js"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./types/index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
   "homepage": "https://postgrejs.panates.com/",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -40,17 +35,6 @@
     "type": "git",
     "url": "https://github.com/panates/postgrejs.git"
   },
-  "engines": {
-    "node": ">=16.0"
-  },
-  "files": [
-    "cjs/",
-    "esm/",
-    "types/",
-    "LICENSE",
-    "README.md",
-    "CHANGELOG.md"
-  ],
   "keywords": [
     "postgresql",
     "postgres",
@@ -62,10 +46,7 @@
     "client",
     "backend",
     "rdbms",
-    "sql",
-    "typescript",
-    "ts",
-    "esm"
+    "sql"
   ],
   "publishConfig": {
     "access": "public"

package/{esm/protocol → protocol}/backend.js

@@ -23,6 +23,7 @@ const ErrorFieldTypes = {
     R: 'routine',
 };
 export class Backend {
+    _buf;
     reset() {
         this._buf = undefined;
     }

package/{esm/protocol → protocol}/buffer-reader.js

@@ -1,6 +1,7 @@
 export class BufferReader {
+    buffer;
+    offset = 0;
     constructor(buffer) {
-        this.offset = 0;
         this.buffer = buffer;
     }
     get length() {

package/{esm/protocol → protocol}/database-error.js

@@ -1,4 +1,20 @@
 export class DatabaseError extends Error {
+    severity;
+    code;
+    detail;
+    hint;
+    position;
+    internalPosition;
+    internalQuery;
+    where;
+    schema;
+    table;
+    column;
+    dataType;
+    constraint;
+    lineNr;
+    colNr;
+    line;
     constructor(msg) {
         super(msg.message);
         Object.assign(this, {

package/{esm/protocol → protocol}/frontend.js

@@ -26,6 +26,7 @@ const StaticSyncBuffer = Buffer.from([
     0x04,
 ]);
 export class Frontend {
+    _io;
     constructor(options) {
         this._io = new SmartBuffer(options?.buffer);
     }

package/{esm/protocol → protocol}/pg-socket.js

@@ -13,12 +13,18 @@ import { SASL } from './sasl.js';
 const DEFAULT_PORT_NUMBER = 5432;
 const COMMAND_RESULT_PATTERN = /^([^\d]+)(?: (\d+)(?: (\d+))?)?$/;
 export class PgSocket extends SafeEventEmitter {
+    options;
+    _state = ConnectionState.CLOSED;
+    _socket;
+    _backend = new Backend();
+    _frontend;
+    _sessionParameters = {};
+    _saslSession;
+    _processID;
+    _secretKey;
     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);
     }

package/{esm/protocol → protocol}/smart-buffer.js

@@ -2,11 +2,17 @@ import * as os from 'os';
 import { writeBigUInt64BE } from '../util/bigint-methods.js';
 import { BufferReader } from './buffer-reader.js';
 export class SmartBuffer extends BufferReader {
+    static DEFAULT_PAGE_SIZE = 4096;
+    static DEFAULT_MAX_SIZE = Math.min(Math.floor(os.totalmem() / 2), 1024 * 1024 * 1024 * 2);
+    _houseKeepInterval;
+    _houseKeepTimer;
+    _lastHouseKeep = 0;
+    _stMaxPages = 1;
+    _length = 0;
+    pageSize;
+    maxSize;
     constructor(cfg) {
         super(Buffer.allocUnsafe(cfg?.pageSize || SmartBuffer.DEFAULT_PAGE_SIZE));
-        this._lastHouseKeep = 0;
-        this._stMaxPages = 1;
-        this._length = 0;
         this._houseKeepInterval = cfg?.houseKeepInterval || 5000;
         this.pageSize = this.buffer.length;
         this.maxSize = cfg?.maxLength || SmartBuffer.DEFAULT_MAX_SIZE;
@@ -169,5 +175,3 @@ export class SmartBuffer extends BufferReader {
         this._stMaxPages = this.length ? Math.ceil(this.length / this.pageSize) : 1;
     }
 }
-SmartBuffer.DEFAULT_PAGE_SIZE = 4096;
-SmartBuffer.DEFAULT_MAX_SIZE = Math.min(Math.floor(os.totalmem() / 2), 1024 * 1024 * 1024 * 2);

package/{esm/util → util}/bigint-methods.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-useless-assignment */
 const big0 = BigInt(0);
 const beAnd = BigInt('0xffffffff');
 const big32 = BigInt(32);

package/cjs/connection/bind-param.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BindParam = void 0;
-class BindParam {
-    constructor(oid, value) {
-        this.oid = oid;
-        this.value = value;
-    }
-}
-exports.BindParam = BindParam;

package/cjs/connection/connection.js

@@ -1,295 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = void 0;
-const constants_js_1 = require("../constants.js");
-const data_type_map_js_1 = require("../data-type-map.js");
-const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
-const bind_param_js_1 = require("./bind-param.js");
-const intl_connection_js_1 = require("./intl-connection.js");
-const prepared_statement_js_1 = require("./prepared-statement.js");
-class Connection extends safe_event_emitter_js_1.SafeEventEmitter {
-    constructor(arg0, arg1) {
-        super();
-        this._notificationListeners = new safe_event_emitter_js_1.SafeEventEmitter();
-        this._closing = false;
-        if (arg0 &&
-            typeof arg0 === 'object' &&
-            typeof arg0.acquire === 'function') {
-            if (!(arg1 instanceof intl_connection_js_1.IntlConnection))
-                throw new TypeError('Invalid argument');
-            this._pool = arg0;
-            this._intlCon = arg1;
-        }
-        else {
-            this._intlCon = new intl_connection_js_1.IntlConnection(arg0);
-        }
-        this._intlCon.on('ready', (...args) => this.emit('ready', ...args));
-        this._intlCon.on('error', (...args) => this.emit('error', ...args));
-        this._intlCon.on('close', (...args) => this.emit('close', ...args));
-        this._intlCon.on('connecting', (...args) => this.emit('connecting', ...args));
-        this._intlCon.on('ready', (...args) => this.emit('ready', ...args));
-        this._intlCon.on('terminate', (...args) => this.emit('terminate', ...args));
-        this._intlCon.on('notification', (msg) => this._handleNotification(msg));
-    }
-    /**
-     * Returns configuration object
-     */
-    get config() {
-        return this._intlCon.config;
-    }
-    /**
-     * Returns true if connection is in a transaction
-     */
-    get inTransaction() {
-        return this._intlCon.inTransaction;
-    }
-    /**
-     * Returns current state of the connection
-     */
-    get state() {
-        return this._intlCon.state;
-    }
-    /**
-     * Returns processId of current session
-     */
-    get processID() {
-        return this._intlCon.processID;
-    }
-    /**
-     * Returns information parameters for current session
-     */
-    get sessionParameters() {
-        return this._intlCon.sessionParameters;
-    }
-    /**
-     * Returns secret key of current session
-     */
-    get secretKey() {
-        return this._intlCon.secretKey;
-    }
-    /**
-     * Connects to the server
-     */
-    async connect() {
-        await this._captureErrorStack(this._intlCon.connect());
-        if (this.state === constants_js_1.ConnectionState.READY)
-            this._closing = false;
-    }
-    /**
-     * Closes connection. You can define how long time the connection will
-     * wait for active queries before terminating the connection.
-     * On the end of the given time, it forces to close the socket and than emits `terminate` event.
-     *
-     * @param terminateWait {number} - Determines how long the connection will wait for active queries before terminating.
-     */
-    async close(terminateWait) {
-        this._notificationListeners.removeAllListeners();
-        this._intlCon.statementQueue.clearQueue();
-        if (this.state === constants_js_1.ConnectionState.CLOSED || this._closing)
-            return;
-        /* istanbul ignore next */
-        if (this.listenerCount('debug')) {
-            this.emit('debug', {
-                location: 'Connection.close',
-                connection: this,
-                message: `[${this.processID}] closing`,
-            });
-        }
-        this._closing = true;
-        if (this._intlCon.refCount > 0 &&
-            typeof terminateWait === 'number' &&
-            terminateWait > 0) {
-            const startTime = Date.now();
-            return this._captureErrorStack(new Promise((resolve, reject) => {
-                /* istanbul ignore next */
-                if (this.listenerCount('debug')) {
-                    this.emit('debug', {
-                        location: 'Connection.close',
-                        connection: this,
-                        message: `[${this.processID}] waiting active queries`,
-                    });
-                }
-                const timer = setInterval(() => {
-                    if (this._intlCon.refCount <= 0 ||
-                        Date.now() > startTime + terminateWait) {
-                        clearInterval(timer);
-                        if (this._intlCon.refCount > 0) {
-                            /* istanbul ignore next */
-                            if (this.listenerCount('debug')) {
-                                this.emit('debug', {
-                                    location: 'Connection.close',
-                                    connection: this,
-                                    message: `[${this.processID}] terminate`,
-                                });
-                            }
-                            this.emit('terminate');
-                        }
-                        this._close().then(resolve).catch(reject);
-                    }
-                }, 50);
-            }));
-        }
-        await this._close();
-    }
-    /**
-     * Executes single or multiple SQL scripts using Simple Query protocol.
-     *
-     * @param sql {string} - SQL script that will be executed
-     * @param options {ScriptExecuteOptions} - Execute options
-     */
-    async execute(sql, options) {
-        this.emit('execute', sql, options);
-        return this._captureErrorStack(this._intlCon.execute(sql, options)).catch((e) => {
-            throw this._handleError(e, sql);
-        });
-    }
-    async query(sql, options) {
-        this._intlCon.assertConnected();
-        /* istanbul ignore next */
-        if (this.listenerCount('debug')) {
-            this.emit('debug', {
-                location: 'Connection.query',
-                connection: this,
-                message: `[${this.processID}] query | ${sql}`,
-                sql,
-            });
-        }
-        this.emit('query', sql, options);
-        const typeMap = options?.typeMap || data_type_map_js_1.GlobalTypeMap;
-        const paramTypes = options?.params?.map(prm => prm instanceof bind_param_js_1.BindParam ? prm.oid : typeMap.determine(prm));
-        const statement = await this.prepare(sql, { paramTypes, typeMap }).catch((e) => {
-            throw this._handleError(e, sql);
-        });
-        try {
-            const params = options?.params?.map(prm => prm instanceof bind_param_js_1.BindParam ? prm.value : prm);
-            return await this._captureErrorStack(statement.execute({ ...options, params }));
-        }
-        finally {
-            await statement.close();
-        }
-    }
-    /**
-     * Creates a PreparedStatement instance
-     * @param sql {string} - SQL script that will be executed
-     * @param options {StatementPrepareOptions} - Options
-     */
-    async prepare(sql, options) {
-        /* istanbul ignore next */
-        if (this.listenerCount('debug')) {
-            this.emit('debug', {
-                location: 'Connection.prepare',
-                connection: this,
-                message: `[${this.processID}] prepare | ${sql}`,
-                sql,
-            });
-        }
-        return await this._captureErrorStack(prepared_statement_js_1.PreparedStatement.prepare(this, sql, options));
-    }
-    /**
-     * Starts a transaction
-     */
-    startTransaction() {
-        return this._captureErrorStack(this._intlCon.startTransaction());
-    }
-    /**
-     * Commits current transaction
-     */
-    commit() {
-        return this._captureErrorStack(this._intlCon.commit());
-    }
-    /**
-     * Rolls back current transaction
-     */
-    rollback() {
-        return this._captureErrorStack(this._intlCon.rollback());
-    }
-    /**
-     * Starts transaction and creates a savepoint
-     * @param name {string} - Name of the savepoint
-     */
-    async savepoint(name) {
-        if (!this._intlCon.inTransaction)
-            await this._intlCon.startTransaction();
-        return this._captureErrorStack(this._intlCon.savepoint(name));
-    }
-    /**
-     * Rolls back current transaction to given savepoint
-     * @param name {string} - Name of the savepoint
-     */
-    rollbackToSavepoint(name) {
-        return this._captureErrorStack(this._intlCon.rollbackToSavepoint(name));
-    }
-    /**
-     * Releases savepoint
-     * @param name {string} - Name of the savepoint
-     */
-    releaseSavepoint(name) {
-        return this._captureErrorStack(this._intlCon.releaseSavepoint(name));
-    }
-    async listen(channel, callback) {
-        if (!/^[A-Z]\w+$/i.test(channel))
-            throw new TypeError(`Invalid channel name`);
-        const registered = !!this._notificationListeners.eventNames().length;
-        this._notificationListeners.on(channel, callback);
-        if (!registered)
-            await this._captureErrorStack(this.query('LISTEN ' + channel));
-    }
-    async unListen(channel) {
-        if (!/^[A-Z]\w+$/i.test(channel))
-            throw new TypeError(`Invalid channel name`);
-        this._notificationListeners.removeAllListeners(channel);
-        await this._captureErrorStack(this.query('UNLISTEN ' + channel));
-    }
-    async unListenAll() {
-        this._notificationListeners.removeAllListeners();
-        await this._captureErrorStack(this.query('UNLISTEN *'));
-    }
-    _handleNotification(msg) {
-        this.emit('notification', msg);
-        this._notificationListeners.emit(msg.channel, msg);
-    }
-    async _close() {
-        if (this._pool) {
-            await this._captureErrorStack(this._pool.release(this));
-            this.emit('release');
-        }
-        else
-            await this._captureErrorStack(this._intlCon.close());
-        this._closing = false;
-    }
-    _handleError(err, script) {
-        if (err.position != null) {
-            const i1 = script.lastIndexOf('\n', err.position - 1) + 1;
-            err.lineNr = [...script.substring(0, i1).matchAll(/\n/g)].length + 1;
-            err.colNr = err.position - i1;
-            const lines = script.split('\n');
-            err.line = lines[err.lineNr - 1];
-            err.message += `\n    at line ${err.lineNr} column ${err.colNr}`;
-            if (err.lineNr > 1)
-                err.message += `\n${String(err.lineNr - 1).padStart(3)}| ${lines[err.lineNr - 2]}`;
-            err.message += `\n${String(err.lineNr).padStart(3)}| ${err.line}\n    .${'-'.repeat(Math.max(err.colNr - 1, 0))}^`;
-        }
-        return err;
-    }
-    async _captureErrorStack(promise) {
-        const stack = new Error().stack;
-        return promise.catch(e => {
-            if (e instanceof Error && stack) {
-                if (e.stack && stack) {
-                    e.stack =
-                        e.stack.substring(0, e.stack.indexOf('\n')) +
-                            '\n' +
-                            stack
-                                .split('\n')
-                                .filter((x, i) => i && !x.includes('._captureErrorStack'))
-                                .join('\n');
-                }
-            }
-            throw e;
-        });
-    }
-    [Symbol.asyncDispose]() {
-        return this.close();
-    }
-}
-exports.Connection = Connection;