expose DataSource type

[erfanium]

It's a good practice to make services datasource injectable. Let's start with this code:

Problem

import { db } from "@/lib/drizzle"

export async function createPost(title) {
  await db.insert(posts).values({ title })
}

The problem with this code is: I can't execute createPost inside a transaction. I can't pass a transaction to it.

If I change it to something like that

import { db } from "@/lib/drizzle"

export async function createPost(trx: Transaction, title) {
  await trx.insert(posts).values({ title })
}

In this case, my function always needs a transaction and won't work just as normal query.

Current Workaround

Currently, we can implement the DataSource interface like this:

const db = drizzle(client, {
  schema: schema,
  logger: process.env.ENABLE_DB_LOGS === "true",
});

type FirstParam<T extends (param: any) => any> = T extends (
  param: infer R
) => any
  ? R
  : any;

type Transaction = FirstParam<FirstParam<typeof db.transaction>>;
export type DataSource = typeof db | Transaction; // Way too hacky, not a good idea for long term

then we can use it like this:

export async function createPost(ds: DataSource, title) {
  await ds.insert(posts).values({ title })
}

or with classes

export class ExamService {
  constructor(private ds: DataSource) {}

  async delete(examId: number) {
    const { ds } = this;

    // delete bookmarks
    const questions = await ds.query.questions.findMany({
      where: eq(S.questions.exam_id, examId),
    });
    for (const question of questions) {
      await ds
        .delete(S.userBookmarkedQuestion)
        .where(eq(S.userBookmarkedQuestion.question_id, question.id));
    }

    // delete answerSheetAnswers and answerSheets
    // ...
  }
}

So by using this pattern, you can build services that can be used with or without transaction. also you can use nested service calls in a single transaction.

Idea

Drizzle should provide us with a DataSource interface using a helper type.

const db = drizzle(client, {
  schema: schema,
  logger: process.env.ENABLE_DB_LOGS === "true",
});

export Type DataSource = DataSourceFor<typeof db>

[Angelelz]

A couple things...

The tx object is almost the same type as the db object. It only has the rollback method that literally just throws an error.
Unless you are using the savepoint feature, you don't really need to use the tx object.
Maybe somebody knows better if there is any other difference?
So...

I can't execute createPost inside a transaction. I can't pass a transaction to it.

Totally fine

When you execute a transaction you are literally just executing the following query: begin transaction
You then can run queries normally, and when the transaction function returns the following query is executed: commit.

That's all there is to it.

import { db } from "@/lib/drizzle"

export async function createPost(trx: typeof db, title) {  // <-- totally fine
  await trx.insert(posts).values({ title })
}

That's my understanding of transactions, if I'm wrong (I very well could be) somebody please correct me.

[erfanium]

Yeah that's correct.
I didn't know that Transaction interface is actually an extend of Database.
my bad, thanks!