pg-promise 11.15.0 → 12.1.0

package/README.md

@@ -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/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.15
+ * ## 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,13 +110,12 @@ 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);
     };
 
     /**
-     * @deprecated
      * Consider using <b>async/await</b> syntax instead, or if you must have
      * pre-generated promises, then $[Promise.allSettled].
      *
@@ -126,7 +123,9 @@ function Task(ctx, tag, isTX, config) {
      * @description
      * Settles a predefined array of mixed values by redirecting to method $[spex.batch].
      *
-     * For complete method documentation see $[spex.batch].
+     * **NOTE:**
+     * Consider using `async/await` syntax instead, or if you must have
+     * pre-generated promises, then $[Promise.allSettled].
      *
      * @param {array} values
      * @param {Object} [options]
@@ -191,9 +190,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 +207,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 +228,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 +272,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 +280,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 +288,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 +322,7 @@ const execute = (ctx, obj, isTX, config) => {
         })
         .catch(error => {
             update(false, false, error);
-            return $p.reject(error);
+            return Promise.reject(error);
         });
 };
 
@@ -336,8 +332,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;
 
     return {
         Task, execute, callback
@@ -415,5 +411,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.15.0",
+  "version": "12.1.0",
   "description": "PostgreSQL interface for Node.js",
   "main": "lib/index.js",
   "typings": "typescript/pg-promise.d.ts",
@@ -44,24 +44,23 @@
     "assert-options": "0.8.3",
     "pg": "8.16.3",
     "pg-minify": "1.8.0",
-    "spex": "3.4.1"
+    "spex": "4.0.1"
   },
   "peerDependencies": {
     "pg-query-stream": "4.10.3"
   },
   "devDependencies": {
-    "@eslint/js": "9.30.1",
-    "@types/node": "24.0.10",
-    "bluebird": "3.7.2",
+    "@eslint/js": "9.34.0",
+    "@types/node": "24.3.0",
     "coveralls": "3.1.1",
-    "cspell": "9.1.3",
-    "eslint": "9.30.1",
+    "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/pg-promise.d.ts

@@ -35,6 +35,17 @@ declare namespace _txMode {
 // API: https://vitaly-t.github.io/pg-promise/module-pg-promise.html
 declare namespace pgPromise {
 
+    interface ISpex {
+        batch: typeof spexLib.batch
+        page: typeof spexLib.page
+        sequence: typeof spexLib.sequence
+        errors: {
+            BatchError: spexLib.errors.BatchError,
+            PageError: spexLib.errors.PageError,
+            SequenceError: spexLib.errors.SequenceError
+        }
+    }
+
     interface IQueryFileOptions {
         debug?: boolean
         minify?: boolean | 'after'
@@ -126,16 +137,6 @@ declare namespace pgPromise {
         table: string
     }
 
-    interface IPromiseConfig {
-        create(resolve: (value?: any) => void, reject?: (reason?: any) => void): Promise<any>
-
-        resolve(value?: any): void
-
-        reject(reason?: any): void
-
-        all(iterable: any): Promise<any>
-    }
-
     type FormattingFilter = '^' | '~' | '#' | ':raw' | ':alias' | ':name' | ':json' | ':csv' | ':list' | ':value';
 
     type QueryColumns<T> = Column<T> | ColumnSet<T> | Array<string | IColumnConfig<T> | Column<T>>;
@@ -281,12 +282,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;
@@ -320,13 +315,12 @@ 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
         readonly queryResult: typeof queryResult
         readonly minify: typeof pgMinify
-        readonly spex: spexLib.ISpex
+        readonly spex: ISpex
         readonly errors: typeof errors
         readonly utils: IUtils
         readonly txMode: typeof txMode
@@ -339,7 +333,7 @@ declare namespace pgPromise {
 
     // Additional methods available inside tasks + transactions;
     // API: https://vitaly-t.github.io/pg-promise/Task.html
-    interface ITask<Ext> extends IBaseProtocol<Ext>, spexLib.ISpexBase {
+    interface ITask<Ext> extends IBaseProtocol<Ext>, ISpex {
         readonly ctx: ITaskContext
     }
 
@@ -445,7 +439,7 @@ declare namespace pgPromise {
 
     // Database object in connected state;
     // API: https://vitaly-t.github.io/pg-promise/Database.html#connect
-    interface IConnected<Ext, C extends pg.IClient> extends IBaseProtocol<Ext>, spexLib.ISpexBase {
+    interface IConnected<Ext, C extends pg.IClient> extends IBaseProtocol<Ext>, ISpex {
         readonly client: C
 
         // Note that for normal connections (working with the pool), method `done` accepts `kill`
@@ -464,7 +458,7 @@ declare namespace pgPromise {
     // 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
@@ -588,7 +582,6 @@ declare namespace pgPromise {
         noWarnings?: boolean
         pgFormatting?: boolean
         pgNative?: boolean
-        promiseLib?: any
         capSQL?: boolean
         schema?: ValidSchema | ((dc: any) => ValidSchema)
 
@@ -613,7 +606,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>

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};