feature(automatic-transactions): Creates a decorator to make transactions easier for the developer

index.js

@@ -52,6 +52,19 @@ function transact (fn, cb) {
   })
 }
 
+// Re-usable code adds the handlers nicely
+const addHandler = (existingHandler, newHandler) => {
+  if (Array.isArray(existingHandler)) {
+    existingHandler.push(newHandler)
+  } else if (typeof existingHandler === 'function') {
+    existingHandler = [existingHandler, newHandler]
+  } else {
+    existingHandler = [newHandler]
+  }
+
+  return existingHandler
+}
+
 function fastifyPostgres (fastify, options, next) {
   let pg = defaultPg
 
@@ -102,6 +115,54 @@ function fastifyPostgres (fastify, options, next) {
     }
   }
 
+  fastify.addHook('onRoute', routeOptions => {
+    const useTransaction = routeOptions.useTransaction || (routeOptions.options && routeOptions.options.useTransaction)
+
+    if (useTransaction) {
+      // This will rollback the transaction if the handler fails at some point
+      const onError = async (req, reply, error) => {
+        req.transactionFailed = true
+
+        try {
+          await req.pg.query('ROLLBACK')
+        } catch (err) {
+          await req.pg.query('ROLLBACK')
+        }
+      }
+
+      routeOptions.onError = addHandler(routeOptions.onError, onError)
+    }
+
+    const preHandler = async (req, reply) => {
+      const client = await pool.connect()
+      req.pg = client
+
+      if (useTransaction) {
+        await req.pg.query('BEGIN')
+      }
+    }
+
+    // This will commit the transaction (or rollback if that fails) and also always
+    // release the client, regardless of error state or useTransaction value
+    const onSend = async (req, reply, payload) => {
+      try {
+        if (!req.transactionFailed && useTransaction) {
+          await req.pg.query('COMMIT')
+        }
+      } catch (err) {
+        if (useTransaction) {
+          await req.pg.query('ROLLBACK')
+        }
+      } finally {
+        req.pg.release()
+      }
+    }
+
+    // Add these handlers
+    routeOptions.preHandler = addHandler(routeOptions.preHandler, preHandler)
+    routeOptions.onSend = addHandler(routeOptions.onSend, onSend)
+  })
+
   next()
 }
 

package.json

@@ -5,7 +5,8 @@
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "standard && tap -J test/*.test.js && npm run test:typescript",
+    "testonly": "tap -J test/*.test.js && npm run test:typescript",
+    "test": "standard --fix && tap -J test/*.test.js && npm run test:typescript",
     "test:typescript": "tsd",
     "test:report": "standard && tap -J --coverage-report=html test/*.test.js",
     "test:verbose": "standard && tap -J test/*.test.js -Rspec",

test/initialization.test.js

@@ -110,7 +110,7 @@ test('Should throw when trying to register multiple instances without giving a n
   })
 })
 
-test('Should not throw when registering a named instance and an unnamed instance)', (t) => {
+test('Should not throw when registering a named instance and an unnamed instance', (t) => {
   t.plan(1)
 
   const fastify = Fastify()
@@ -191,7 +191,7 @@ test('fastify.pg namespace should exist', (t) => {
   })
 })
 
-test('fastify.pg.test namespace should exist', (t) => {
+test('fastify.pg custom namespace should exist if a name is set', (t) => {
   t.plan(6)
 
   const fastify = Fastify()

test/query.test.js

@@ -4,6 +4,7 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('fastify')
 const fastifyPostgres = require('../index')
+
 const {
   BAD_DB_NAME,
   connectionString,
@@ -134,7 +135,7 @@ test('When fastify.pg root namespace is used:', (t) => {
   t.end()
 })
 
-test('When fastify.pg.test namespace is used:', (t) => {
+test('When fastify.pg custom namespace is used:', (t) => {
   t.test('Should be able to connect and perform a query', (t) => {
     t.plan(4)
 

test/req-initialization.test.js

@@ -0,0 +1,202 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('fastify')
+const fastifyPostgres = require('../index')
+const { connectionString } = require('./helpers')
+
+// // A failed set of queries with transactions on, on test, NONE of these entries should be visible in the DB
+// fastify.get('/fail', { useTransaction: true }, async (req, reply) => {
+//   console.log('in fail registration')
+
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-in-q1'])
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-in-q2'])
+//   await req.pg.query('INSERT INTO nope(username) VALUES($1) RETURNING id', ['fail-opt-in-q3'])
+
+//   reply.send('Fail example')
+// })
+
+// // A passing set of queries with transactions on, on test, ALL of these entries should be visible in the DB
+// fastify.get('/pass', { useTransaction: true }, async (req, reply) => {
+//   console.log('in pass registration')
+
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-in-q1'])
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-in-q2'])
+
+//   reply.send('Pass example')
+// })
+
+// // A failed set of queries with transactions off, on test, THE FIRST TWO of these entries should be visible in the DB
+// fastify.get('/fail-opt-out', { useTransaction: false }, async (req, reply) => {
+//   console.log('in fail registration')
+
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-out-q1'])
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-out-q2'])
+//   await req.pg.query('INSERT INTO nope(username) VALUES($1) RETURNING id', ['fail-opt-out-q3'])
+
+//   reply.send('Fail example')
+// })
+
+// // A passing set of queries with transactions off, on test, ALL of these entries should be visible in the DB
+// fastify.get('/pass-opt-out', { useTransaction: false }, async (req, reply) => {
+//   console.log('in pass registration')
+
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-out-q1'])
+//   await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-out-q2'])
+
+//   reply.send('Pass example')
+// })
+
+const extractUserCount = response => parseInt(JSON.parse(response.payload).rows[0].userCount)
+
+test('fastify postgress useTransaction route option - ', t => {
+  test('set to true - ', t => {
+    test('passing queries provided', async t => {
+      const fastify = Fastify()
+      t.teardown(() => fastify.close())
+
+      await fastify.register(fastifyPostgres, {
+        connectionString
+      })
+
+      await fastify.pg.query('TRUNCATE users')
+
+      await fastify.get('/count-users', async (req, reply) => {
+        const result = await req.pg.query('SELECT COUNT(*) AS "userCount" FROM users WHERE username=\'pass-opt-in\'')
+
+        reply.send(result)
+      })
+
+      await fastify.get('/pass', { useTransaction: true }, async (req, reply) => {
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-in'])
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-in'])
+        reply.send('complete')
+      })
+
+      await fastify.inject({
+        method: 'GET',
+        url: '/pass'
+      })
+
+      const response = await fastify.inject({
+        method: 'GET',
+        url: '/count-users'
+      })
+
+      t.is(extractUserCount(response), 2)
+    })
+    test('failing queries provided', async t => {
+      const fastify = Fastify()
+      t.teardown(() => fastify.close())
+
+      await fastify.register(fastifyPostgres, {
+        connectionString
+      })
+
+      await fastify.pg.query('TRUNCATE users')
+
+      await fastify.get('/count-users', async (req, reply) => {
+        const result = await req.pg.query('SELECT COUNT(*) AS "userCount" FROM users WHERE username=\'fail-opt-in\'')
+
+        reply.send(result)
+      })
+
+      await fastify.get('/fail', { useTransaction: true }, async (req, reply) => {
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-in'])
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-in'])
+        await req.pg.query('INSERT INTO nope(username) VALUES($1) RETURNING id', ['fail-opt-in'])
+        reply.send('complete')
+      })
+
+      await fastify.inject({
+        method: 'GET',
+        url: '/fail'
+      })
+
+      const response = await fastify.inject({
+        method: 'GET',
+        url: '/count-users'
+      })
+
+      t.is(extractUserCount(response), 0)
+    })
+
+    t.end()
+  })
+  test('set to false - ', t => {
+    test('passing queries provided', async t => {
+      const fastify = Fastify()
+      t.teardown(() => fastify.close())
+
+      await fastify.register(fastifyPostgres, {
+        connectionString
+      })
+
+      await fastify.pg.query('TRUNCATE users')
+
+      await fastify.get('/count-users', async (req, reply) => {
+        const result = await req.pg.query('SELECT COUNT(*) AS "userCount" FROM users WHERE username=\'pass-opt-out\'')
+
+        reply.send(result)
+      })
+
+      await fastify.get('/pass-opt-out', { useTransaction: false }, async (req, reply) => {
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-out'])
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['pass-opt-out'])
+        reply.send('complete')
+      })
+
+      await fastify.inject({
+        method: 'GET',
+        url: '/pass-opt-out'
+      })
+
+      const response = await fastify.inject({
+        method: 'GET',
+        url: '/count-users'
+      })
+
+      t.is(extractUserCount(response), 2)
+    })
+    test('failing queries provided', async t => {
+      const fastify = Fastify()
+      t.teardown(() => fastify.close())
+
+      await fastify.register(fastifyPostgres, {
+        connectionString
+      })
+
+      await fastify.pg.query('TRUNCATE users')
+
+      await fastify.get('/count-users', async (req, reply) => {
+        const result = await req.pg.query('SELECT COUNT(*) AS "userCount" FROM users WHERE username=\'fail-opt-out\'')
+
+        reply.send(result)
+      })
+
+      await fastify.get('/fail-opt-out', { useTransaction: false }, async (req, reply) => {
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-out'])
+        await req.pg.query('INSERT INTO users(username) VALUES($1) RETURNING id', ['fail-opt-out'])
+        await req.pg.query('INSERT INTO nope(username) VALUES($1) RETURNING id', ['fail-opt-out'])
+        reply.send('complete')
+      })
+
+      await fastify.inject({
+        method: 'GET',
+        url: '/fail-opt-out'
+      })
+
+      const response = await fastify.inject({
+        method: 'GET',
+        url: '/count-users'
+      })
+
+      t.is(extractUserCount(response), 2)
+    })
+
+    t.end()
+  })
+
+  t.end()
+})