Show warning when query inside transaction block is not using trx

I have had quite a few occasions where I’ve created a transaction block but I forget to use the trxobject and it causes errors in my app logic. For example,

function insertAndReturnUsers(userObj) {
  return knex.transaction(trx => {
    return trx.insert(userObj).into('table_a')
      .then(() => getUsers())
  })
  .catch(err => {
    // Transaction failed.. do something
  });
}


function getUsers() {
  return knex('users').select('*');
}

In this case insertAndReturnUsers function has a bug. It doesn’t return the newly created user when listing all users. I tend to do this mistake a lot and almost never my intention is to do a query outside the transaction.

Could it be possible to add a developer warning when accidentally doing this ?

[tgriesser]

I’ve thought about this (and I’m interested to hear any other ideas here). There isn’t really a simple way to do this, since it’s possible to lift the transaction object out of the transaction block.

Instead I’m working on adding a new path for transactions, keeping but likely eventually deprecating the current syntax, where you’d instead call as a function and receive a transaction object:

const trx = knex.transaction(/* optional config */)

trx.insert(userObj).into('table_a')
  .then(() => trx.select('*').from('users'))
  .then(trx.commit)
  .catch(trx.rollback)

this would make it simpler to create a transaction which properly works across an entire request / response cycle:

app.use((req, res, next) => {
  req.knex = knex.transaction()
  onHeaders(req, () => {
    if (!req.knex.complete) {
      console.warn('Transaction was not committed or rolled back')
      req.knex.commit()
    }
  })
  next()
})
app.use((err, req, res, next) => {
  if (req.knex && !req.knex.complete) {
    req.knex.rollback(err)
  }
  //...
})

Then you’d just be sure to use req.knex and every query would always be on the same connection / transaction. It would also be possible to limit this behavior to post requests if you want.

app.use((req, res, next) => {
  if (req.method === 'POST' || req.method === 'PUT' || req.method === 'DELETE') {
    req.knex = knex.transaction()
    onHeaders(req, () => {
      if (!req.knex.complete) {
        console.warn('Transaction was not committed or rolled back')
        req.knex.commit()
      }
    })
  } else {
    req.knex = knex
  }
  next()
})

Finally, these transaction objects would be lazy / inexpensive, there wouldn’t actually be any connection checked out of the pool and no queries would be sent to the database until the first query is executed.

[kibertoad]

@timbrownsf I think transactionProvider might be a helpful solution for you. Check out this example from documentation:

// Does not start a transaction yet
const trxProvider = knex.transactionProvider();

const books = [
  {title: 'Canterbury Tales'},
  {title: 'Moby Dick'},
  {title: 'Hamlet'}
];

// Starts a transaction
const trx = await trxProvider();
const ids = await trx('catalogues')
  .insert({name: 'Old Books'}, 'id')
books.forEach((book) => book.catalogue_id = ids[0]);
await  trx('books').insert(books);

// Reuses same transaction
const sameTrx = await trxProvider();
const ids2 = await sameTrx('catalogues')
  .insert({name: 'New Books'}, 'id')
books.forEach((book) => book.catalogue_id = ids2[0]);
await sameTrx('books').insert(books);