Correct TypeScript type for tx when passing Drizzle ORM transactions to another function?

[riculum]

I’m using Drizzle ORM and need to pass the transaction object (tx) to another function. Currently, I have defined tx as any, but I’d like to replace it with the correct, type-safe version.

Here’s an example of my function:

const addSubscriptions = ({
  orderId,
  subscriptions,
  tx,
}: {
  orderId: string,
  subscriptions: z.infer<typeof orderValidation>['subscriptions'],
  tx: any, // <-- I'd like to replace `any` with the correct type
}) => {
  // Function implementation
}

[zemd]

I found that whether DatabaseType or TransactionType can be used

export type DatabaseType = typeof database;
export type TransactionType = Parameters<Parameters<DatabaseType['transaction']>[0]>[0];

[ghost]

This one worked like a charm! Thank you very much :)

[immiProgrammer]

good but my approach:

tx: Parameters<Parameters<(typeof db)["transaction"]>[0]>[0]

// or
import type { PgQueryResultHKT, PgTransaction } from "drizzle-orm/pg-core";
import type { ExtractTablesWithRelations } from "drizzle-orm";

tx: PgTransaction<
    PgQueryResultHKT,
    Record<string, never>,
    ExtractTablesWithRelations<Record<string, never>>
>

[mintydev789]

import type { PgTransaction } from "drizzle-orm/pg-core"; is no longer available (I'm on Beta 11 rn).

[ogaken-1]

Hello!

I recently realized that drizzle actually already provides typed tx.

Are you defining a union database type?
I've noticed that when using a union database type, the transaction parameter seems to be resolved as any.

import type { drizzle as postgres } from "drizzle-orm/node-postgres";
import type { drizzle as pglite } from "drizzle-orm/pglite";
import type * as schema from "../schema/index";

export type Schema = typeof schema;
export type Postgres = ReturnType<typeof postgres<Schema>>;
export type PGlite = ReturnType<typeof pglite<Schema>>;
export type Database = Postgres | PGlite;
const any = (db: Database) => {
  // (parameter) tx: any
  db.transaction(tx => {})
}
const correct = (db: Postgres) => {
  // (parameter) tx: PgTransaction<NodePgQueryResultHKT, typeof schema, ExtractTablesWithRelations<typeof schema>>
  db.transaction(tx => {})
}

[ghost]

But how can I extract these to serve as argument type for another function?

[ogaken-1]

I just realized I completely misread this discussion. My apologies.

[sheikhameen]

tx is already typed. You can use that inferred type to make a reusable type and export it. Drizzle also exposes the types to build the Transaction:

import type { ExtractTablesWithRelations,} from 'drizzle-orm';
import type { NodePgQueryResultHKT } from 'drizzle-orm/node-postgres';
import { PgTransaction } from 'drizzle-orm/pg-core';
import type * as schema from '@/database/schema.js';

export type Transaction = PgTransaction<NodePgQueryResultHKT, typeof schema, ExtractTablesWithRelations<typeof schema>>;

You can now simply import and use Transaction wherever needed.

[mintydev789]

'import type { PgTransaction } from "drizzle-orm/pg-core";' is no longer available (I'm on Beta 11 rn).

[mintydev789]

For anyone else discovering this discussion, this is how you infer the type as of the latest beta (11):

import type { PgAsyncTransaction } from "drizzle-orm/pg-core";
import type { PostgresJsQueryResultHKT } from "drizzle-orm/postgres-js";
import { relations } from "./relations.ts";

export type DbTransactionType = PgAsyncTransaction<PostgresJsQueryResultHKT, Record<string, never>, typeof relations>;