Callback-free interactive transactions

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

https://github.com/prisma/prisma/issues/1844#issuecomment-1067348856

[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)

[millsp]

Hey everyone, I am excited to share that we are working on a new proposal that will help in solving this. While we are not keen to add this to our API, we are very willing to allow you to create and share custom extensions. This is how you would do it:

const prisma = new PrismaClient().$extends({
	$client: {
		begin() { ... }, // the code I shared above
	}
})

const tx = await prisma.$begin()

await tx.user.create(...)
await tx.user.update(...)

await tx.$commit()

We would love to see what you can build with Prisma Client Extensions. I’d appreciate if you can take some time to read and share your feedback on the proposal.