pg-promise 11.14.0 → 12.0.0

package/README.md

@@ -2,7 +2,7 @@ pg-promise
 ==========
 
 [![Build Status](https://github.com/vitaly-t/pg-promise/actions/workflows/ci.yml/badge.svg)](https://github.com/vitaly-t/pg-promise/actions/workflows/ci.yml)
-[![Node Version](https://img.shields.io/badge/nodejs-14%20--%2024-green.svg?logo=node.js&style=flat)](https://nodejs.org)
+[![Node Version](https://img.shields.io/badge/nodejs-16%20--%2024-green.svg?logo=node.js&style=flat)](https://nodejs.org)
 [![Postgres Version](https://img.shields.io/badge/postgresql-10%20--%2016-green.svg?logo=postgresql&style=flat)](https://www.postgresql.org)
 
 ---
@@ -52,7 +52,6 @@ Built on top of [node-postgres], this library adds the following:
 * Declarative approach to handling query results
 * Global events reporting for central handling
 * Extensive support for external SQL files
-* Support for all promise libraries
 
 At its inception in 2015, this library was only adding promises to the base driver, hence the name `pg-promise`.
 And while the original name was kept, the library's functionality was vastly extended, with promises now being
@@ -999,7 +998,7 @@ to force the pool to shut down all the connections it holds:
 db.$pool.end(); // shuts down the connection pool associated with the Database object
 ``` 
 
-For example, if you are using the [Bluebird] library, you can chain the last promise in the process like this:
+For example, you can chain the last promise in the process like this:
 
 ```js
 .finally(db.$pool.end);
@@ -1117,7 +1116,6 @@ See the relevant API: [pgp.end], [Database.$pool]
 <!-- External Links -->
 
 [node-postgres]:https://github.com/brianc/node-postgres
-[Bluebird]:https://github.com/petkaantonov/bluebird
 [SQL injection]:https://en.wikipedia.org/wiki/SQL_injection
 [Symbol]:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol
 [idleTimeoutMillis]:https://github.com/brianc/node-postgres/blob/master/packages/pg/lib/defaults.js

package/lib/connect.js

@@ -16,8 +16,8 @@ const npm = {
     formatting: require('./formatting')
 };
 
-function poolConnect(ctx, db, config) {
-    return config.promise((resolve, reject) => {
+function poolConnect(ctx, db) {
+    return new Promise((resolve, reject) => {
         const p = db.$pool;
         if (p.ending) {
             db.$destroy();
@@ -37,7 +37,7 @@ function poolConnect(ctx, db, config) {
                 reject(err);
             } else {
                 if ('$useCount' in client) {
-                    // Make sure useCount drops to 1, if it ever reaches maximum integer number;
+                    // Make sure useCount drops to 1, if it ever reaches the maximum integer number;
                     // We do not drop it to zero, to avoid rerun of initialization queries that
                     // usually check for useCount === 0;
                     // istanbul ignore if
@@ -75,7 +75,7 @@ function poolConnect(ctx, db, config) {
 }
 
 function directConnect(ctx, config) {
-    return config.promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
         const client = new config.pgp.pg.Client(ctx.cn);
         client.connect(err => {
             if (err) {
@@ -94,7 +94,7 @@ function directConnect(ctx, config) {
                     useCount: 0,
                     release() {
                         client.end = end;
-                        const p = config.promise((res, rej) => client.end().then(res).catch(rej));
+                        const p = new Promise((res, rej) => client.end().then(res).catch(rej));
                         Events.disconnect(ctx, client);
                         client.removeListener('error', onError);
                         return p;
@@ -173,6 +173,6 @@ function setSchema(client, ctx) {
 }
 
 module.exports = config => ({
-    pool: (ctx, db) => poolConnect(ctx, db, config),
+    pool: (ctx, db) => poolConnect(ctx, db),
     direct: ctx => directConnect(ctx, config)
 });

package/lib/database.js

@@ -122,7 +122,6 @@ const npm = {
 function Database(cn, dc, config) {
 
     const dbThis = this,
-        $p = config.promise,
         poolConnection = typeof cn === 'string' ? {connectionString: cn} : cn,
         pool = new config.pgp.pg.Pool(poolConnection),
         endMethod = pool.end;
@@ -249,7 +248,7 @@ function Database(cn, dc, config) {
         const self = {
             query(query, values, qrm) {
                 if (!ctx.db) {
-                    return $p.reject(new Error(npm.text.queryDisconnected));
+                    return Promise.reject(new Error(npm.text.queryDisconnected));
                 }
                 return config.$npm.query.call(this, ctx, query, values, qrm);
             },
@@ -338,7 +337,7 @@ function Database(cn, dc, config) {
             })
             .catch(error => {
                 ctx.disconnect();
-                return $p.reject(error);
+                return Promise.reject(error);
             });
     };
 
@@ -351,27 +350,8 @@ function Database(cn, dc, config) {
      * Properties available in the object:
      * - `pgp` - instance of the entire library after initialization
      * - `options` - the library's {@link module:pg-promise Initialization Options} object
-     * - `promiseLib` - instance of the promise library that's used
-     * - `promise` - generic promise interface that uses `promiseLib` via 4 basic methods:
-     *   - `promise((resolve, reject) => {})` - to create a new promise
-     *   - `promise.resolve(value)` - to resolve with a value
-     *   - `promise.reject(reason)` - to reject with a reason
-     *   - `promise.all(iterable)` - to resolve an iterable list of promises
      * - `version` - this library's version
      * - `$npm` _(hidden property)_ - internal module cache
-     *
-     * @example
-     *
-     * // Using the promise protocol as configured by pg-promise:
-     *
-     * const $p = db.$config.promise;
-     *
-     * const resolvedPromise = $p.resolve('some data');
-     * const rejectedPromise = $p.reject('some reason');
-     *
-     * const newPromise = $p((resolve, reject) => {
-     *     // call either resolve(data) or reject(reason) here
-     * });
      */
     npm.utils.addReadProp(this, '$config', config, true);
 
@@ -1353,12 +1333,12 @@ function Database(cn, dc, config) {
                 if ('cnd' in args.options) {
                     cnd = typeof cnd === 'function' ? cnd.call(obj, obj) : !!cnd;
                 } else {
-                    cnd = !obj.ctx; // create task, if it is the top level
+                    cnd = !obj.ctx; // create a task if it is the top level
                 }
-                // reusable only if condition fails, and not top-level:
+                // reusable only if the condition fails, and not top-level:
                 args.options.reusable = !cnd && !!obj.ctx;
             } catch (e) {
-                return $p.reject(e);
+                return Promise.reject(e);
             }
             return taskProcessor.call(this, args, false);
         };
@@ -1541,17 +1521,17 @@ function Database(cn, dc, config) {
                 const reusable = args.options.reusable;
                 args.options.reusable = !cnd && obj.ctx && typeof reusable === 'function' ? reusable.call(obj, obj) : !!reusable;
             } catch (e) {
-                return $p.reject(e);
+                return Promise.reject(e);
             }
             return taskProcessor.call(this, args, args.options.cnd);
         };
 
         // Task method;
-        // Resolves with result from the callback function;
+        // Resolves with the result from the callback function;
         function taskProcessor(params, isTX) {
 
             if (typeof params.cb !== 'function') {
-                return $p.reject(new TypeError('Callback function is required.'));
+                return Promise.reject(new TypeError('Callback function is required.'));
             }
 
             if (params.options.reusable) {
@@ -1595,12 +1575,12 @@ function Database(cn, dc, config) {
                 })
                 .catch(error => {
                     taskCtx.disconnect();
-                    return $p.reject(error);
+                    return Promise.reject(error);
                 });
         }
 
         function addServerVersion(target, client) {
-            // Exclude else-case from coverage, because it can only occur with Native Bindings.
+            // Exclude else-case from the coverage because it can only occur with Native Bindings.
             // istanbul ignore else
             if (client.serverVersion) {
                 npm.utils.addReadProp(target, 'serverVersion', client.serverVersion);
@@ -1632,7 +1612,7 @@ function onError(err) {
 module.exports = config => {
     const npmLocal = config.$npm;
     npmLocal.connect = npmLocal.connect || npm.connect(config);
-    npmLocal.query = npmLocal.query || npm.query(config);
+    npmLocal.query = npmLocal.query || npm.query();
     npmLocal.task = npmLocal.task || npm.task(config);
     return Database;
 };

package/lib/events.js

@@ -531,7 +531,6 @@ module.exports = {Events};
  * It is set for all events.
  * 
  * @property {string|undefined} queryFilePath
- * **Added in v11.14**<br/>
  * File path of a {@link QueryFile}, if the query comes from an external SQL file.
  * This is set only when the query originates from a {@link QueryFile} and only for events {@link event:query query} and {@link event:error error}.
  *

package/lib/index.js

@@ -12,17 +12,18 @@ var v = process.versions.node.split('.'),
     highVer = +v[0];
 
 // istanbul ignore next
-if (highVer < 14) {
+if (highVer < 16) {
 
-    // From pg-promise v11.0.0, the oldest supported Node.js is v14.0.0
+    // From pg-promise v11.15.0, the oldest supported Node.js is v16.0.0
 
-    // Node.js v12.0.0 was supported up to pg-promise v10.15.4
-    // Node.js v8.0.0 was supported up to pg-promise v10.14.2
+    // Node.js v14.x was supported up to pg-promise v11.14.0
+    // Node.js v12.x was supported up to pg-promise v10.15.4
+    // Node.js v8.x was supported up to pg-promise v10.14.2
     // Node.js v7.6.0 was supported up to pg-promise v10.3.5
     // Node.js v4.5.0 was supported up to pg-promise v8.7.5
     // Node.js v0.10 was supported up to pg-promise v5.5.8
 
-    throw new Error('Minimum Node.js version supported by pg-promise is 14.0.0');
+    throw new Error('Minimum Node.js version supported by pg-promise is 16.0.0');
 }
 
 module.exports = require('./main');

package/lib/main.js

@@ -7,12 +7,10 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {PromiseAdapter} = require('./promise-adapter');
 const {DatabasePool} = require('./database-pool');
 const {PreparedStatement, ParameterizedQuery} = require('./types');
 const {QueryFile} = require('./query-file');
 const {queryResult} = require('./query-result');
-const {parsePromise} = require('./promise-parser');
 const {assert} = require('./assert');
 
 const npm = {
@@ -36,7 +34,7 @@ let originalClientConnect;
  * @module pg-promise
  *
  * @description
- * ## pg-promise v11.14
+ * ## pg-promise v12.0
  * All documentation here is for the latest official release only.
  *
  * ### Initialization Options
@@ -69,25 +67,6 @@ let originalClientConnect;
  *
  * This is a static option (can only be set prior to initialization).
  *
- * @property {object|function} [options.promiseLib=Promise]
- * Overrides the default (ES6 Promise) promise library for its internal use.
- *
- * Example below sets to use $[Bluebird] - the best and recommended promise library. It is the fastest one,
- * and supports $[Long Stack Traces], essential for debugging promises.
- *
- * ```js
- * const Promise = require('bluebird');
- * const initOptions = {
- *     promiseLib: Promise
- * };
- * const pgp = require('pg-promise')(initOptions);
- * ```
- *
- * All existing promise libraries are supported. The ones with recognizable signature are used automatically,
- * while the rest can be configured via the $[Promise Adapter].
- *
- * This is a static option (can only be set prior to initialization).
- *
  * @property {boolean} [options.capSQL=false]
  * Capitalizes any SQL generated by the library.
  *
@@ -178,22 +157,18 @@ let originalClientConnect;
  */
 function $main(options) {
 
-    options = assert(options, ['pgFormatting', 'pgNative', 'promiseLib', 'capSQL', 'noWarnings',
+    options = assert(options, ['pgFormatting', 'pgNative', 'capSQL', 'noWarnings',
         'connect', 'disconnect', 'query', 'receive', 'task', 'transact', 'error', 'extend', 'schema']);
 
     let pg = npm.pg;
-    const p = parsePromise(options.promiseLib);
 
     const config = {
-        version: npm.package.version,
-        promiseLib: p.promiseLib,
-        promise: p.promise
+        version: npm.package.version
     };
 
     npm.utils.addReadProp(config, '$npm', {}, true);
 
     // Locking properties that cannot be changed later:
-    npm.utils.addReadProp(options, 'promiseLib', options.promiseLib);
     npm.utils.addReadProp(options, 'pgNative', !!options.pgNative);
 
     config.options = options;
@@ -235,7 +210,7 @@ function $main(options) {
     /**
      * @member {external:PG} pg
      * @description
-     * Instance of the $[pg] library that's being used, depending on initialization option `pgNative`:
+     * Instance of the $[pg] library being used, depending on initialization option `pgNative`:
      *  - regular `pg` module instance, without option `pgNative`, or equal to `false` (default)
      *  - `pg` module instance with $[Native Bindings], if option `pgNative` was set.
      *
@@ -328,16 +303,6 @@ const rootNameSpace = {
      */
     queryResult,
 
-    /**
-     * @member {PromiseAdapter} PromiseAdapter
-     * @readonly
-     * @description
-     * {@link PromiseAdapter} class.
-     *
-     * Available as `pgp.PromiseAdapter`, before and after initializing the library.
-     */
-    PromiseAdapter,
-
     /**
      * @member {ParameterizedQuery} ParameterizedQuery
      * @readonly

package/lib/query.js

@@ -30,13 +30,12 @@ const badMask = queryResult.one | queryResult.many; // unsupported combination b
 
 //////////////////////////////
 // Generic query method;
-function $query(ctx, query, values, qrm, config) {
+function $query(ctx, query, values, qrm) {
 
     const special = qrm instanceof SpecialQuery && qrm;
-    const $p = config.promise;
 
     if (special && special.isStream) {
-        return npm.stream.call(this, ctx, query, values, config);
+        return npm.stream.call(this, ctx, query, values);
     }
 
     const opt = ctx.options,
@@ -122,7 +121,7 @@ function $query(ctx, query, values, qrm, config) {
 
     if (!error && (!pgFormatting || entityType)) {
         try {
-            // use 'pg-promise' implementation of values formatting;
+            // use 'pg-promise' implementation of value formatting;
             if (entityType) {
                 params = undefined;
                 query = npm.formatting.formatEntity(query, values, {capSQL, type: entityType});
@@ -143,7 +142,7 @@ function $query(ctx, query, values, qrm, config) {
         }
     }
 
-    return $p((resolve, reject) => {
+    return new Promise((resolve, reject) => {
 
         if (notifyReject()) {
             return;
@@ -194,7 +193,7 @@ function $query(ctx, query, values, qrm, config) {
                         const len = data.length;
                         if (len) {
                             if (len > 1 && qrm & queryResult.one) {
-                                // one row was expected, but returned multiple;
+                                // one row was expected but returned multiple;
                                 error = new QueryResultError(qrec.multiple, lastResult, query, params);
                             } else {
                                 if (!(qrm & (queryResult.one | queryResult.many))) {
@@ -271,8 +270,4 @@ function makeIterable(r) {
     };
 }
 
-module.exports = config => {
-    return function (ctx, query, values, qrm) {
-        return $query.call(this, ctx, query, values, qrm, config);
-    };
-};
+module.exports = () => $query;

package/lib/stream.js

@@ -17,28 +17,26 @@ const npm = {
 ////////////////////////////////////////////
 // Streams query data into any destination,
 // with the help of pg-query-stream library.
-function $stream(ctx, qs, initCB, config) {
-
-    const $p = config.promise;
+function $stream(ctx, qs, initCB) {
 
     // istanbul ignore next:
     // we do not provide code coverage for the Native Bindings specifics
     if (ctx.options.pgNative) {
-        return $p.reject(new Error(npm.text.nativeStreaming));
+        return Promise.reject(new Error(npm.text.nativeStreaming));
     }
     // Stream class was renamed again, see the following issue:
     // https://github.com/brianc/node-postgres/issues/2412
     if (!qs || !qs.constructor || qs.constructor.name !== 'QueryStream') {
         // invalid or missing stream object;
-        return $p.reject(new TypeError(npm.text.invalidStream));
+        return Promise.reject(new TypeError(npm.text.invalidStream));
     }
     if (qs._reading || qs._closed) {
         // stream object is in the wrong state;
-        return $p.reject(new Error(npm.text.invalidStreamState));
+        return Promise.reject(new Error(npm.text.invalidStreamState));
     }
     if (typeof initCB !== 'function') {
         // parameter `initCB` must be passed as the initialization callback;
-        return $p.reject(new TypeError(npm.text.invalidStreamCB));
+        return Promise.reject(new TypeError(npm.text.invalidStreamCB));
     }
 
     let error = Events.query(ctx.options, getContext());
@@ -46,7 +44,7 @@ function $stream(ctx, qs, initCB, config) {
     if (error) {
         error = getError(error);
         Events.error(ctx.options, error, getContext());
-        return $p.reject(error);
+        return Promise.reject(error);
     }
 
     const stream = ctx.db.client.query(qs);
@@ -61,7 +59,7 @@ function $stream(ctx, qs, initCB, config) {
         release();
         error = getError(e);
         Events.error(ctx.options, error, getContext());
-        return $p.reject(error);
+        return Promise.reject(error);
     }
 
     const start = Date.now();
@@ -117,7 +115,7 @@ function $stream(ctx, qs, initCB, config) {
         };
     }
 
-    return $p((res, rej) => {
+    return new Promise((res, rej) => {
         resolve = res;
         reject = rej;
     });

package/lib/task.js

@@ -61,8 +61,6 @@ const npm = {
  */
 function Task(ctx, tag, isTX, config) {
 
-    const $p = config.promise;
-
     /**
      * @member {TaskContext} Task#ctx
      * @readonly
@@ -112,7 +110,7 @@ function Task(ctx, tag, isTX, config) {
     // generic query method;
     this.query = function (query, values, qrm) {
         if (!ctx.db) {
-            return $p.reject(new Error(npm.text.looseQuery));
+            return Promise.reject(new Error(npm.text.looseQuery));
         }
         return config.$npm.query.call(this, ctx, query, values, qrm);
     };
@@ -191,9 +189,8 @@ function Task(ctx, tag, isTX, config) {
  * @param config
  * @returns {Promise.<TResult>}
  */
-const callback = (ctx, obj, cb, config) => {
+const callback = (ctx, obj, cb) => {
 
-    const $p = config.promise;
     let result;
 
     try {
@@ -209,12 +206,12 @@ const callback = (ctx, obj, cb, config) => {
             dc: ctx.dc,
             ctx: ctx.ctx
         });
-        return $p.reject(err); // reject with the error;
+        return Promise.reject(err); // reject with the error;
     }
     if (result && typeof result.then === 'function') {
         return result; // result is a valid promise object;
     }
-    return $p.resolve(result);
+    return Promise.resolve(result);
 };
 
 /**
@@ -230,8 +227,6 @@ const callback = (ctx, obj, cb, config) => {
  */
 const execute = (ctx, obj, isTX, config) => {
 
-    const $p = config.promise;
-
     // updates the task context and notifies the client;
     function update(start, success, result) {
         const c = ctx.ctx;
@@ -276,7 +271,7 @@ const execute = (ctx, obj, isTX, config) => {
                         return cbData;
                     }
                     update(false, false, cbReason);
-                    return $p.reject(cbReason);
+                    return Promise.reject(cbReason);
                 },
                 err => {
                     // either COMMIT or ROLLBACK has failed, which is impossible
@@ -284,7 +279,7 @@ const execute = (ctx, obj, isTX, config) => {
                     // istanbul ignore next:
                     update(false, false, err);
                     // istanbul ignore next:
-                    return $p.reject(err);
+                    return Promise.reject(err);
                 }),
             err => {
                 // BEGIN has failed, which is impossible to replicate in a test
@@ -292,7 +287,7 @@ const execute = (ctx, obj, isTX, config) => {
                 // istanbul ignore next:
                 update(false, false, err);
                 // istanbul ignore next:
-                return $p.reject(err);
+                return Promise.reject(err);
             });
     }
 
@@ -326,7 +321,7 @@ const execute = (ctx, obj, isTX, config) => {
         })
         .catch(error => {
             update(false, false, error);
-            return $p.reject(error);
+            return Promise.reject(error);
         });
 };
 
@@ -336,8 +331,8 @@ module.exports = config => {
     // istanbul ignore next:
     // we keep 'npm.query' initialization here, even though it is always
     // pre-initialized by the 'database' module, for integrity purpose.
-    npmLocal.query = npmLocal.query || npm.query(config);
-    npmLocal.spex = npmLocal.spex || npm.spex(config.promiseLib);
+    npmLocal.query = npmLocal.query || npm.query();
+    npmLocal.spex = npmLocal.spex || npm.spex(Promise);
 
     return {
         Task, execute, callback
@@ -415,5 +410,4 @@ module.exports = config => {
  * Once the operation has finished, this property contains the result, depending on property `success`:
  * - data resolved by the operation, if `success = true`
  * - error / rejection reason, if `success = false`
- *
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-promise",
-  "version": "11.14.0",
+  "version": "12.0.0",
   "description": "PostgreSQL interface for Node.js",
   "main": "lib/index.js",
   "typings": "typescript/pg-promise.d.ts",
@@ -38,30 +38,29 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=14.0"
+    "node": ">=16.0"
   },
   "dependencies": {
     "assert-options": "0.8.3",
-    "pg": "8.14.1",
-    "pg-minify": "1.7.0",
+    "pg": "8.16.3",
+    "pg-minify": "1.8.0",
     "spex": "3.4.1"
   },
   "peerDependencies": {
-    "pg-query-stream": "4.8.1"
+    "pg-query-stream": "4.10.3"
   },
   "devDependencies": {
-    "@eslint/js": "9.28.0",
-    "@types/node": "22.15.29",
-    "bluebird": "3.7.2",
+    "@eslint/js": "9.34.0",
+    "@types/node": "24.3.0",
     "coveralls": "3.1.1",
-    "cspell": "9.0.2",
-    "eslint": "9.28.0",
-    "globals": "16.2.0",
+    "cspell": "9.2.0",
+    "eslint": "9.34.0",
+    "globals": "16.3.0",
     "istanbul": "0.4.5",
     "jasmine-node": "3.0.0",
     "jsdoc": "4.0.4",
     "JSONStream": "1.3.5",
     "tslint": "6.1.3",
-    "typescript": "5.8.3"
+    "typescript": "5.9.2"
   }
 }

package/typescript/README.md

@@ -21,7 +21,7 @@ const {value} = await db.one('SELECT 123 as value');
 #### With Extensions
 
 The library supports dynamic protocol extensions, via event [extend], which requires
-explicit extension interface to be declared and parameterized, as shown below.
+an explicit extension interface to be declared and parameterized, as shown below.
 
 ```ts
 import * as pgPromise from 'pg-promise';

package/typescript/pg-promise.d.ts

@@ -7,17 +7,6 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-/////////////////////////////////////////
-// Requires pg-promise v11.0.0 or later.
-/////////////////////////////////////////
-
-// We use ES6 as static promise here, because generic promises are still not supported.
-// Follow the links below:
-// https://stackoverflow.com/questions/36593087/using-a-custom-promise-as-a-generic-type
-// https://github.com/Microsoft/TypeScript/issues/1213
-
-type XPromise<T> = Promise<T>;
-
 import * as pg from './pg-subset';
 import * as pgMinify from 'pg-minify';
 import * as spexLib from 'spex';
@@ -137,16 +126,6 @@ declare namespace pgPromise {
         table: string
     }
 
-    interface IPromiseConfig {
-        create(resolve: (value?: any) => void, reject?: (reason?: any) => void): XPromise<any>
-
-        resolve(value?: any): void
-
-        reject(reason?: any): void
-
-        all(iterable: any): XPromise<any>
-    }
-
     type FormattingFilter = '^' | '~' | '#' | ':raw' | ':alias' | ':name' | ':json' | ':csv' | ':list' | ':value';
 
     type QueryColumns<T> = Column<T> | ColumnSet<T> | Array<string | IColumnConfig<T> | Column<T>>;
@@ -292,12 +271,6 @@ declare namespace pgPromise {
         toString(level?: number): string
     }
 
-    // PromiseAdapter class;
-    // API: https://vitaly-t.github.io/pg-promise/PromiseAdapter.html
-    class PromiseAdapter {
-        constructor(api: IPromiseConfig)
-    }
-
     const txMode: typeof _txMode;
     const utils: IUtils;
     const as: IFormatting;
@@ -308,7 +281,7 @@ declare namespace pgPromise {
     // We export this interface only to be able to help IntelliSense cast extension types correctly,
     // which doesn't always work, depending on the version of IntelliSense being used.
     interface IDatabase<Ext, C extends pg.IClient = pg.IClient> extends IBaseProtocol<Ext> {
-        connect(options?: IConnectionOptions<C>): XPromise<IConnected<Ext, C>>
+        connect(options?: IConnectionOptions<C>): Promise<IConnected<Ext, C>>
 
         /////////////////////////////////////////////////////////////////////////////
         // Hidden, read-only properties, for integrating with third-party libraries:
@@ -331,7 +304,6 @@ declare namespace pgPromise {
     interface IMain<Ext = {}, C extends pg.IClient = pg.IClient> {
         <T = Ext, C extends pg.IClient = pg.IClient>(cn: string | pg.IConnectionParameters<C>, dc?: any): IDatabase<T, C> & T
 
-        readonly PromiseAdapter: typeof PromiseAdapter
         readonly PreparedStatement: typeof PreparedStatement
         readonly ParameterizedQuery: typeof ParameterizedQuery
         readonly QueryFile: typeof QueryFile
@@ -369,89 +341,89 @@ declare namespace pgPromise {
     interface IBaseProtocol<Ext> {
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#query
-        query<T = any>(query: QueryParam, values?: any, qrm?: queryResult): XPromise<T>
+        query<T = any>(query: QueryParam, values?: any, qrm?: queryResult): Promise<T>
 
         // result-specific methods;
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#none
-        none(query: QueryParam, values?: any): XPromise<null>
+        none(query: QueryParam, values?: any): Promise<null>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#one
-        one<T = any>(query: QueryParam, values?: any, cb?: (value: any) => T, thisArg?: any): XPromise<T>
+        one<T = any>(query: QueryParam, values?: any, cb?: (value: any) => T, thisArg?: any): Promise<T>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#oneOrNone
-        oneOrNone<T = any>(query: QueryParam, values?: any, cb?: (value: any) => T, thisArg?: any): XPromise<T | null>
+        oneOrNone<T = any>(query: QueryParam, values?: any, cb?: (value: any) => T, thisArg?: any): Promise<T | null>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#many
-        many<T = any>(query: QueryParam, values?: any): XPromise<T[]>
+        many<T = any>(query: QueryParam, values?: any): Promise<T[]>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#manyOrNone
-        manyOrNone<T = any>(query: QueryParam, values?: any): XPromise<T[]>
+        manyOrNone<T = any>(query: QueryParam, values?: any): Promise<T[]>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#any
-        any<T = any>(query: QueryParam, values?: any): XPromise<T[]>
+        any<T = any>(query: QueryParam, values?: any): Promise<T[]>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#result
-        result<T, R = IResultExt<T>>(query: QueryParam, values?: any, cb?: (value: IResultExt<T>) => R, thisArg?: any): XPromise<R>
+        result<T, R = IResultExt<T>>(query: QueryParam, values?: any, cb?: (value: IResultExt<T>) => R, thisArg?: any): Promise<R>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#multiResult
-        multiResult(query: QueryParam, values?: any): XPromise<pg.IResult[]>
+        multiResult(query: QueryParam, values?: any): Promise<pg.IResult[]>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#multi
-        multi<T = any>(query: QueryParam, values?: any): XPromise<Array<T[]>>
+        multi<T = any>(query: QueryParam, values?: any): Promise<Array<T[]>>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#stream
-        stream(qs: NodeJS.ReadableStream, init: (stream: NodeJS.ReadableStream) => void): XPromise<{
+        stream(qs: NodeJS.ReadableStream, init: (stream: NodeJS.ReadableStream) => void): Promise<{
             processed: number,
             duration: number
         }>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#func
-        func<T = any>(funcName: string, values?: any, qrm?: queryResult): XPromise<T>
+        func<T = any>(funcName: string, values?: any, qrm?: queryResult): Promise<T>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#proc
-        proc<T = any>(procName: string, values?: any, cb?: (value: any) => T, thisArg?: any): XPromise<T | null>
+        proc<T = any>(procName: string, values?: any, cb?: (value: any) => T, thisArg?: any): Promise<T | null>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#map
-        map<T = any>(query: QueryParam, values: any, cb: (row: any, index: number, data: any[]) => T, thisArg?: any): XPromise<T[]>
+        map<T = any>(query: QueryParam, values: any, cb: (row: any, index: number, data: any[]) => T, thisArg?: any): Promise<T[]>
 
         // API: https://vitaly-t.github.io/pg-promise/Database.html#each
-        each<T = any>(query: QueryParam, values: any, cb: (row: any, index: number, data: any[]) => void, thisArg?: any): XPromise<T[]>
+        each<T = any>(query: QueryParam, values: any, cb: (row: any, index: number, data: any[]) => void, thisArg?: any): Promise<T[]>
 
         // Tasks;
         // API: https://vitaly-t.github.io/pg-promise/Database.html#task
-        task<T>(cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        task<T>(cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        task<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        task<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        task<T>(options: { tag?: any }, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        task<T>(options: { tag?: any }, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
         // Conditional Tasks;
         // API: https://vitaly-t.github.io/pg-promise/Database.html#taskIf
-        taskIf<T>(cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        taskIf<T>(cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        taskIf<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        taskIf<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        taskIf<T>(options: ITaskIfOptions<Ext>, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        taskIf<T>(options: ITaskIfOptions<Ext>, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
         // Transactions;
         // API: https://vitaly-t.github.io/pg-promise/Database.html#tx
-        tx<T>(cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        tx<T>(cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        tx<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        tx<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
         tx<T>(options: {
             tag?: any,
             mode?: _txMode.TransactionMode | null
-        }, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        }, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
         // Conditional Transactions;
         // API: https://vitaly-t.github.io/pg-promise/Database.html#txIf
-        txIf<T>(cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        txIf<T>(cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        txIf<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        txIf<T>(tag: string | number, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
 
-        txIf<T>(options: ITxIfOptions<Ext>, cb: (t: ITask<Ext> & Ext) => T | XPromise<T>): XPromise<T>
+        txIf<T>(options: ITxIfOptions<Ext>, cb: (t: ITask<Ext> & Ext) => T | Promise<T>): Promise<T>
     }
 
     // Database object in connected state;
@@ -465,17 +437,17 @@ declare namespace pgPromise {
 
         // But for direct connections (connect({direct: true})), `kill` flag is ignored, because
         // the connection is always closed physically, which may take time, and so in this case
-        // the method returns a Promise, to indicate when the connection finished closing.
-        done(kill?: boolean): void | XPromise<void>;
+        // the method returns a Promise to indicate when the connection finished closing.
+        done(kill?: boolean): void | Promise<void>;
 
-        // Repeated calls are not allowed, and will throw an error.
+        // Repeated calls are not allowed and will throw an error.
     }
 
     // Event context extension for tasks + transactions;
     // See: https://vitaly-t.github.io/pg-promise/global.html#TaskContext
     interface ITaskContext {
 
-        // these are set in the beginning of each task/transaction:
+        // these are set at the beginning of each task/transaction:
         readonly context: any
         readonly parent: ITaskContext | null
         readonly connected: boolean
@@ -510,7 +482,7 @@ declare namespace pgPromise {
         query: any
         params: any,
         values: any,
-        queryFilePath?: string, 
+        queryFilePath?: string,
         ctx: ITaskContext
     }
 
@@ -599,7 +571,6 @@ declare namespace pgPromise {
         noWarnings?: boolean
         pgFormatting?: boolean
         pgNative?: boolean
-        promiseLib?: any
         capSQL?: boolean
         schema?: ValidSchema | ((dc: any) => ValidSchema)
 
@@ -609,7 +580,7 @@ declare namespace pgPromise {
 
         query?(e: IEventContext<C>): void
 
-        // NOTE: result is undefined when data comes from QueryStream, i.e. via method Database.stream
+        // NOTE: The result is undefined when data comes from QueryStream, i.e. via method Database.stream
         receive?(e: { data: any[], result: IResultExt | void, ctx: IEventContext<C> }): void
 
         task?(e: IEventContext<C>): void
@@ -624,7 +595,6 @@ declare namespace pgPromise {
     // API: https://vitaly-t.github.io/pg-promise/Database.html#$config
     interface ILibConfig<Ext, C extends pg.IClient = pg.IClient> {
         version: string
-        promiseLib: any
         promise: IGenericPromise
         options: IInitOptions<Ext, C>
         pgp: IMain<Ext, C>
@@ -723,13 +693,13 @@ declare namespace pgPromise {
     }
 
     interface IGenericPromise {
-        (cb: (resolve: (value?: any) => void, reject: (reason?: any) => void) => void): XPromise<any>
+        (cb: (resolve: (value?: any) => void, reject: (reason?: any) => void) => void): Promise<any>
 
         resolve(value?: any): void
 
         reject(reason?: any): void
 
-        all(iterable: any): XPromise<any>
+        all(iterable: any): Promise<any>
     }
 }
 

package/typescript/pg-subset.d.ts

@@ -30,7 +30,7 @@ declare namespace pg {
         oid: number
         dataTypeID: number
 
-        // NOTE: properties below are not available within Native Bindings:
+        // NOTE: The properties below are not available within Native Bindings:
 
         tableID: number
         columnID: number

package/lib/promise-adapter.js

@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 2015-present, Vitaly Tomilov
- *
- * See the LICENSE file at the top-level directory of this distribution
- * for licensing information.
- *
- * Removal or modification of this copyright notice is prohibited.
- */
-
-const {assert} = require('./assert');
-
-/**
- * @class PromiseAdapter
- * @summary Adapter for the primary promise operations.
- * @description
- * Provides compatibility with promise libraries that cannot be recognized automatically,
- * via functions that implement the primary operations with promises:
- *
- *  - construct a new promise with a callback function
- *  - resolve a promise with some result data
- *  - reject a promise with a reason
- *  - resolve an array of promises
- *
- * The type is available from the library's root: `pgp.PromiseAdapter`.
- *
- * @param {object} api
- * Promise API configuration object.
- *
- * Passing in anything other than an object will throw {@link external:TypeError TypeError} = `Adapter requires an api configuration object.`
- *
- * @param {function} api.create
- * A function that takes a callback parameter and returns a new promise object.
- * The callback parameter is expected to be `function(resolve, reject)`.
- *
- * Passing in anything other than a function will throw {@link external:TypeError TypeError} = `Function 'create' must be specified.`
- *
- * @param {function} api.resolve
- * A function that takes an optional data parameter and resolves a promise with it.
- *
- * Passing in anything other than a function will throw {@link external:TypeError TypeError} = `Function 'resolve' must be specified.`
- *
- * @param {function} api.reject
- * A function that takes an optional error parameter and rejects a promise with it.
- *
- * Passing in anything other than a function will throw {@link external:TypeError TypeError} = `Function 'reject' must be specified.`
- *
- * @param {function} api.all
- * A function that resolves an array of promises.
- *
- * Passing in anything other than a function will throw {@link external:TypeError TypeError} = `Function 'all' must be specified.`
- *
- * @returns {PromiseAdapter}
- */
-class PromiseAdapter {
-    constructor(api) {
-
-        if (!api || typeof api !== 'object') {
-            throw new TypeError('Adapter requires an api configuration object.');
-        }
-
-        api = assert(api, ['create', 'resolve', 'reject', 'all']);
-
-        this.create = api.create;
-        this.resolve = api.resolve;
-        this.reject = api.reject;
-        this.all = api.all;
-
-        if (typeof this.create !== 'function') {
-            throw new TypeError('Function \'create\' must be specified.');
-        }
-
-        if (typeof this.resolve !== 'function') {
-            throw new TypeError('Function \'resolve\' must be specified.');
-        }
-
-        if (typeof this.reject !== 'function') {
-            throw new TypeError('Function \'reject\' must be specified.');
-        }
-
-        if (typeof this.all !== 'function') {
-            throw new TypeError('Function \'all\' must be specified.');
-        }
-    }
-}
-
-module.exports = {PromiseAdapter};

package/lib/promise-parser.js

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2015-present, Vitaly Tomilov
- *
- * See the LICENSE file at the top-level directory of this distribution
- * for licensing information.
- *
- * Removal or modification of this copyright notice is prohibited.
- */
-
-const {PromiseAdapter} = require('./promise-adapter');
-
-//////////////////////////////////////////
-// Parses and validates a promise library;
-function parse(pl) {
-
-    let promise;
-    if (pl instanceof PromiseAdapter) {
-        promise = function (func) {
-            return pl.create(func);
-        };
-        promise.resolve = pl.resolve;
-        promise.reject = pl.reject;
-        promise.all = pl.all;
-        return promise;
-    }
-    const t = typeof pl;
-    if (t === 'function' || t === 'object') {
-        const Root = typeof pl.Promise === 'function' ? pl.Promise : pl;
-        promise = function (func) {
-            return new Root(func);
-        };
-        promise.resolve = Root.resolve;
-        promise.reject = Root.reject;
-        promise.all = Root.all;
-        if (typeof promise.resolve === 'function' &&
-            typeof promise.reject === 'function' &&
-            typeof promise.all === 'function') {
-            return promise;
-        }
-    }
-
-    throw new TypeError('Invalid promise library specified.');
-}
-
-function parsePromise(promiseLib) {
-    const result = {promiseLib};
-    if (promiseLib) {
-        result.promise = parse(promiseLib);
-    } else {
-        result.promise = parse(Promise);
-        result.promiseLib = Promise;
-    }
-    return result;
-}
-
-module.exports = {parsePromise};