Callback-free interactive transactions

[millsp]

Problem

Some users are asking for a less restricted way for opening an interactive transaction. Instead of having a callback for the transaction, there would be manual calls to $begin, $commit, and $rollback.

Suggested solution

Example of a use-case

describe('some test', () => {
   let trx: Transaction;

   beforeEach(async () => {
      trx = await prisma.$begin();
      jest.mock('./prisma', () => trx);
   });

   afterEach(async () => {
      await trx.$rollback();
   });

   it('.....', () => {
      // ....
   });
});

Alternatives

Additional context

#1844 (comment)

[sijakubo]

That would be great to have. We are currently facing the exact same issue

[janpio]

Can you elaborate on your use case @sijakubo? That is always valuable to have in such issues as signal why someone wants a feature really.

[sroettering]

I would love this feature as well. In my use case we have integration tests running with jest that need to be wrapped in a transaction so we can run many tests in parallel without bothering about side effects for other tests. There are of course techniques like cloning databases or using multiple schemas but they have limits. So a simple transaction would in most cases be more than enough. With the callback solution this is not possible right now.
The proposed API already looks promising for this.

[sijakubo]

Hi @janpio,

We are trying to ramp up our CI speed and in order to do so, we need to run the database integration tests in parallel. This is currently not possible, due to the lack of manual transaction handling within prisma.

I have multiple years of experience in Java / Spring where it is almost default behavior to run your tests within a transaction, which rollbacks after the execution of the test to run several tests in parallel.

The suggested example is exactly what we would need to increase our CI speed significantly

[garrensmith]

I was thinking that instead of having a manual transactions, why not rather change the test to be something like:

  describeInTransaction('some test', (trx) => {
   
   beforeEach(async () => {
           jest.mock('./prisma', () => trx);
   });

   it('.....', () => {
      trx.user.findUnique(...)
   });
});

With the function describeInTransaction being a wrapper over a transaction and the jest test.

[millsp]

Hey folks, I prototyped something today (with type safety!). Do you mind giving it a try and share your feedback?

Prototype setup

import { PrismaClient } from "@prisma/client"

type CtorParams<C> = C extends new (...args: infer P) => any ? P[0] : never
type TxClient = Parameters<Parameters<PrismaClient['$transaction']>[0]>[0]
const ROLLBACK = { [Symbol.for('prisma.client.extension.rollback')]: true }

async function $begin(client: PrismaClient) {
    let setTxClient: (txClient: TxClient) => void
    let commit: () => void
    let rollback: () => void

    // a promise for getting the tx inner client
    const txClient = new Promise<TxClient>((res) => {
        setTxClient = (txClient) => res(txClient)
    })

    // a promise for controlling the transaction
    const txPromise = new Promise((_res, _rej) => {
        commit = () => _res(undefined)
        rollback = () => _rej(ROLLBACK)
    })

    // opening a transaction to control externally
    const tx = client.$transaction((txClient) => {
        setTxClient(txClient as TxClient)

        return txPromise.catch((e) => {
            if (e === ROLLBACK) return
            throw e
        })
    })

    return Object.assign(await txClient, {
        $commit: async () => { commit(); await tx },
        $rollback: async () => { rollback(); await tx }
    } as TxClient & { $commit: () => Promise<void>, $rollback: () => Promise<void> })
}

// patches the prisma client with a $begin method
function getTxClient(options?: CtorParams<typeof PrismaClient>) {
    const client = new PrismaClient(options)
    
    return Object.assign(client, {
        $begin: () => $begin(client)
    }) as PrismaClient & { $begin: () => ReturnType<typeof $begin> }
}

Example

const prisma = getTxClient()
await prisma.user.deleteMany()
const tx = await prisma.$begin()

await tx.user.create({
    data: {
        email: Date.now() + '@email.io'
    }
})

const users0 = await tx.user.findMany({})
console.log(users0)

await tx.$rollback()

const users1 = await prisma.user.findMany({})
console.log(users1)