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]

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

[leuchthelp]

This should be the way for Sqlite & Sqlite-proxy with relations for latest rc4

import { SQLiteTransaction } from "drizzle-orm/sqlite-core";
import type { SqliteRemoteResult } from "drizzle-orm/sqlite-proxy";
import { relations } from "./relations.ts";

export type TransactionType = SQLiteTransaction<"async", SqliteRemoteResult, Record<string, never>, typeof relations>;

[leuchthelp]

and like this for pglite:

import type { PgAsyncTransaction } from "drizzle-orm/pg-core";
import type { PgliteQueryResultHKT } from "drizzle-orm/pglite";
import { relations } from "./relations.ts";

type TransactionType = PgAsyncTransaction<
  PgliteQueryResultHKT,
  typeof relations
>;