[REMOVE] Bluebird

db-session.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const DOMAIN_TO_SESSION = new WeakMap()
-const Promise = require('bluebird')
 
 const TxSessionConnectionPair = require('./lib/tx-session-connpair.js')
 const SessionConnectionPair = require('./lib/session-connpair.js')
@@ -45,19 +44,19 @@ const api = module.exports = {
 
   atomic (operation) {
     return function atomic$operation () {
-      return Promise.try(() => {
-        const args = [].slice.call(arguments)
-        return api.session.atomic(operation.bind(this), args)
-      })
+      const args = [].slice.call(arguments)
+      return (async () => {
+        return await api.session.atomic(operation.bind(this), args)
+      })()
     }
   },
 
   transaction (operation) {
     return function transaction$operation () {
-      return Promise.try(() => {
-        const args = [].slice.call(arguments)
-        return api.session.transaction(operation.bind(this), args)
-      })
+      const args = [].slice.call(arguments)
+      return (async () => {
+        return await api.session.transaction(operation.bind(this), args)
+      })()
     }
   },
 
@@ -140,15 +139,16 @@ class Session {
     }, operation, args)
 
     const releasePair = getConnPair.then(pair => {
-      return getResult.reflect().then(result => {
+      return getResult.then(result => {
         this.metrics.onTransactionFinish(baton, operation, args, result)
-        return result.isFulfilled()
-          ? pair.release()
-          : pair.release(result.reason())
+        return pair.release()
+      }).catch(reason => {
+        this.metrics.onTransactionFinish(baton, operation, args, reason)
+        return pair.release(reason)
       })
     })
 
-    return releasePair.return(getResult)
+    return releasePair.then(() => getResult)
   }
 
   atomic (operation, args) {
@@ -209,15 +209,16 @@ class TransactionSession {
     }, operation, args)
 
     const releasePair = atomicConnPair.then(pair => {
-      return getResult.reflect().then(result => {
+      return getResult.then(result => {
         this.metrics.onAtomicFinish(baton, operation, args, result)
-        return result.isFulfilled()
-          ? pair.release()
-          : pair.release(result.reason())
+        return pair.release()
+      }).catch(reason => {
+        this.metrics.onAtomicFinish(baton, operation, args, reason)
+        return pair.release(reason)
       })
     })
 
-    return releasePair.return(getResult)
+    return releasePair.then(() => getResult)
   }
 
   // NB: for use in tests _only_!)
@@ -233,59 +234,64 @@ class AtomicSession extends TransactionSession {
   }
 }
 
-function Session$RunWrapped (parent,
-                             createSession,
-                             getConnPair,
-                             before,
-                             after,
-                             operation,
-                             args) {
-  return getConnPair.then(pair => {
+function Session$RunWrapped(
+  parent,
+  createSession,
+  getConnPair,
+  before,
+  after,
+  operation,
+  args
+) {
+  return getConnPair.then((pair) => {
     const subdomain = domain.create()
     const session = createSession(pair)
     parent.metrics.onSubsessionStart(parent, session)
     DOMAIN_TO_SESSION.set(subdomain, session)
 
     const runBefore = new Promise((resolve, reject) => {
-      return pair.connection.query(
-        before,
-        err => err ? reject(err) : resolve()
+      return pair.connection.query(before, (err) =>
+        err ? reject(err) : resolve()
       )
     })
 
     return runBefore.then(() => {
       const getResult = Promise.resolve(
-        subdomain.run(() => Promise.try(() => {
-          return operation.apply(null, args)
-        }))
+        subdomain.run(() => {
+          return Promise.resolve().then(() => {
+            return operation.apply(null, args)
+          })
+        })
       )
 
-      const reflectedResult = getResult.reflect()
+      const waitOperation = getResult
+        .then((result) => {
+          return Promise.all([
+            Promise.resolve(result),
+            Promise.resolve(session.operation),
+          ])
+        })
+        .finally(() => {
+          markInactive(subdomain)
+        })
 
-      const waitOperation = Promise.join(
-        reflectedResult,
-        reflectedResult.then(() => session.operation)
-      )
-      .finally(markInactive(subdomain))
-      .return(reflectedResult)
-
-      const runCommitStep = waitOperation.then(result => {
-        return new Promise((resolve, reject) => {
-          return pair.connection.query(
-            result.isFulfilled()
-              ? after.success
-              : after.failure,
-            err => err ? reject(err) : resolve()
-          )
+      const runCommitStep = waitOperation
+        .then(([result]) => {
+          return new Promise((resolve, reject) => {
+            return pair.connection.query(
+              result ? after.success : after.failure,
+              (err) => (err ? reject(err) : resolve())
+            )
+          })
         })
-      }).then(
-        () => parent.metrics.onSubsessionFinish(parent, session),
-        err => {
-          parent.metrics.onSubsessionFinish(parent, session)
-          throw err
-        }
-      )
-      return runCommitStep.return(getResult)
+        .then(
+          () => parent.metrics.onSubsessionFinish(parent, session),
+          (err) => {
+            parent.metrics.onSubsessionFinish(parent, session)
+            throw err
+          }
+        )
+      return runCommitStep.then(() => getResult)
     })
   })
 }

lib/tx-session-connpair.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const Promise = require('bluebird')
-
 const RESOLVE_SYM = Symbol('resolve')
 const REJECT_SYM = Symbol('reject')
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npm/pg-db-session",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "domain-attached database sessions",
   "main": "db-session.js",
   "scripts": {
@@ -29,8 +29,5 @@
     "pg": "6.1.6",
     "standard": "10.0.2",
     "tap": "10.3.2"
-  },
-  "dependencies": {
-    "bluebird": "3.5.0"
   }
 }

test/basic-atomic-concurrency-test.js

@@ -1,18 +1,19 @@
 'use strict'
 
-const Promise = require('bluebird')
 const test = require('tap').test
 
 const domain = require('../lib/domain.js')
 const db = require('../db-session.js')
 
 const LOGS = []
 
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+
 const runOperations = db.transaction(function runOperations (inner) {
   return Promise.all(Array.from(Array(4)).map((_, idx) => {
     return idx % 2 === 0 ? inner(idx) : db.getConnection().then(connPair => {
       LOGS.push(`load ${idx}`)
-      return Promise.delay(5).then(() => {
+      return delay(5).then(() => {
         LOGS.push(`release ${idx}`)
         connPair.release()
       })
@@ -22,10 +23,10 @@ const runOperations = db.transaction(function runOperations (inner) {
 
 function runSubOperation (rootIdx) {
   return Promise.all(Array.from(Array(4)).map((_, idx) => {
-    return Promise.delay(5).then(() => {
+    return delay(5).then(() => {
       return db.getConnection().then(connPair => {
         LOGS.push(`load ${rootIdx} ${idx}`)
-        return Promise.delay(5).then(() => {
+        return delay(5).then(() => {
           LOGS.push(`release ${rootIdx} ${idx}`)
           connPair.release()
         })

test/basic-atomic-error-test.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const Promise = require('bluebird')
 const test = require('tap').test
 
 const domain = require('../lib/domain.js')
@@ -17,16 +16,24 @@ test('test error in previous query', assert => {
   domain1.run(() => {
     return db.atomic(() => {
       const first = db.getConnection().then(conn => {
-        return Promise.promisify(conn.connection.query)('ONE')
-          .then(() => conn.release())
+        return new Promise((resolve, reject) => {
+          conn.connection.query('ONE', err => {
+            if (err) return reject(err)
+            resolve()
+          })
+        }).then(() => conn.release())
           .catch(err => conn.release(err))
       })
 
       const second = first.then(() => {
         return db.getConnection()
       }).then(conn => {
-        return Promise.promisify(conn.connection.query)('TWO')
-          .then(() => conn.release())
+        return new Promise((resolve, reject) => {
+          conn.connection.query('TWO', err => {
+            if (err) return reject(err)
+            resolve()
+          })
+        }).then(() => conn.release())
           .catch(err => conn.release(err))
       })
 
@@ -141,7 +148,7 @@ test('test error in ROLLBACK: does not reuse connection', assert => {
         pair.release()
         throw new Error('any kind of error, really')
       })
-    })().reflect()
+    })().catch(() => {})
 
     const second = db.getConnection().then(pair => {
       // with concurrency=1, we will try to re-use
@@ -151,7 +158,7 @@ test('test error in ROLLBACK: does not reuse connection', assert => {
       pair.release()
     })
 
-    return Promise.join(first, second)
+    return Promise.all([first, second])
   })
   .catch(err => assert.fail(err))
   .finally(() => domain1.exit())
@@ -169,4 +176,4 @@ test('test error in ROLLBACK: does not reuse connection', assert => {
       }
     }
   }
-})
+})

test/basic-rollback-test.js

@@ -16,7 +16,10 @@ test('rolling back transaction calls ROLLBACK', assert => {
   domain1.run(() => {
     return db.transaction(() => {
       throw new Error('no thanks')
-    })().reflect()
+    })().then(
+      () => null,
+      () => null
+    )
   })
   .then(() => assert.equal(LOGS.join(' '), 'BEGIN ROLLBACK'))
   .catch(err => assert.fail(err))
@@ -44,7 +47,10 @@ test('rolling back atomic calls ROLLBACK', assert => {
   domain1.run(() => {
     return db.atomic(() => {
       throw new Error('no thanks')
-    })().reflect()
+    })().then(
+      () => null,
+      () => null
+    )
   })
   .then(() => {
     assert.equal(LOGS.join('\n').replace(/_[\d_]+$/gm, '_TS'), `

test/basic-session-concurrency-test.js

@@ -1,13 +1,14 @@
 'use strict'
 
-const Promise = require('bluebird')
 const test = require('tap').test
 
 const domain = require('../lib/domain.js')
 const db = require('../db-session.js')
 
 const LOGS = []
 
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+
 test('test root session concurrency=0', assert => {
   const start = process.domain
   const domain1 = domain.create()
@@ -166,7 +167,7 @@ function runOperations () {
   return Promise.all(Array.from(Array(8)).map((_, idx) => {
     return db.getConnection().then(connPair => {
       LOGS.push(`load ${idx}`)
-      return Promise.delay(5).then(() => {
+      return delay(5).then(() => {
         LOGS.push(`release ${idx}`)
         connPair.release()
       })