Using a single method for multiple Drizzle connections at the same time

[IArnaut2]

I used Get Started guides for PostgreSQL and SQLite to make Drizzle connections to two databases in one project. I created usersSchema and a configs for each Drizzle connection.
https://github.com/IArnaut2/Drizzle-Multi-DB-Question

The index file has main method which has the database and table as parameters. I call the method for each Drizzle connection.

import "dotenv/config";
import { eq } from "drizzle-orm";
import { drizzle as drizzleDev } from "drizzle-orm/node-postgres";
import { drizzle as drizzleTest } from "drizzle-orm/libsql";

import { usersTable as devUsersTable } from "./db/dev/schema";
import { usersTable as testUsersTable } from "./db/test/schema";

const devDb = drizzleDev(process.env.DATABASE_URL!);
const testDb = drizzleTest(process.env.DB_FILE_NAME!);

async function main(db: any, table: typeof devUsersTable | typeof testUsersTable) {
    const user: typeof table.$inferInsert = {
        name: "John",
        age: 30,
        email: "john@example.com"
    };

    await db.insert(table).values(user);
    console.log("New user created!");

    const users = await db.select().from(table);
    console.log("Getting all users from the database: ", users);

    await db.update(table).set({ age: 31 }).where(eq(table.email, user.email));
    console.log("User info updated!");

    await db.delete(table).where(eq(table.email, user.email));
    console.log("User deleted!");
}

console.log("DEV")
console.log("------------------------------------------------------------------------------------------------------------------------");
main(devDb, devUsersTable).then(() => {
    console.log()
    console.log("TEST")
    console.log("------------------------------------------------------------------------------------------------------------------------");
    main(testDb, testUsersTable);
});

The type of table is typeof devUsersTable | typeof testUsersTable. However, I don't know what the type of db parameter should be.

[dor-sr]

There's no single db type that covers both, because Drizzle types each dialect separately: NodePgDatabase.insert() only takes a PgTable and LibSQLDatabase.insert() only takes a SQLiteTable. If you type db as NodePgDatabase | LibSQLDatabase, TypeScript fails on insert, select and update with "This expression is not callable".

Overloads work, and they also catch a wrong db/table pair at the call site:

import type { NodePgDatabase } from "drizzle-orm/node-postgres";
import type { LibSQLDatabase } from "drizzle-orm/libsql";

async function main(db: NodePgDatabase, table: typeof devUsersTable): Promise<void>;
async function main(db: LibSQLDatabase, table: typeof testUsersTable): Promise<void>;
async function main(db: any, table: typeof devUsersTable | typeof testUsersTable) {
  // your body, unchanged
}

If the SQLite db is only for tests, another option is PGlite (Postgres running in-process). Then you need only one schema, and db can be typed as PgDatabase<PgQueryResultHKT> from drizzle-orm/pg-core.

I cloned your repo and tested this on drizzle-orm 0.45.3. The CRUD flow runs on libsql and on PGlite, and main(testDb, devUsersTable) is now a type error.

[halilertekin]

The overload approach above protects the call site, but its implementation still has db: any. If your goal is one reusable CRUD workflow without any inside it, I would put the common boundary one level above Drizzle's dialect-specific query builders.

Define a small repository interface and bind each database to its own table in an adapter. The shared main() then accepts the repository, so it cannot accidentally mix a PostgreSQL connection with a SQLite table.

This is a self-contained example using the name, age, and email fields from your question; in your project, replace the example table declarations with your existing schema imports:

import { eq } from 'drizzle-orm';
import { pgTable, serial, text, integer, type PgDatabase, type PgQueryResultHKT } from 'drizzle-orm/pg-core';
import { sqliteTable, integer as sqliteInteger, text as sqliteText } from 'drizzle-orm/sqlite-core';
import type { LibSQLDatabase } from 'drizzle-orm/libsql';

export const pgUsers = pgTable('users', {
  id: serial('id').primaryKey(), name: text('name').notNull(),
  age: integer('age').notNull(), email: text('email').notNull().unique(),
});
export const sqliteUsers = sqliteTable('users', {
  id: sqliteInteger('id').primaryKey({ autoIncrement: true }),
  name: sqliteText('name').notNull(), age: sqliteInteger('age').notNull(),
  email: sqliteText('email').notNull().unique(),
});
export type NewUser = { name: string; age: number; email: string };
export type User = NewUser & { id: number };
export interface UsersRepository {
  create(user: NewUser): Promise<void>;
  list(): Promise<User[]>;
  setAge(email: string, age: number): Promise<void>;
  remove(email: string): Promise<void>;
}
export function postgresUsers<TSchema extends Record<string, unknown>>(db: PgDatabase<PgQueryResultHKT, TSchema>): UsersRepository {
  return {
    async create(user) { await db.insert(pgUsers).values(user); },
    async list() { return await db.select().from(pgUsers); },
    async setAge(email, age) { await db.update(pgUsers).set({ age }).where(eq(pgUsers.email, email)); },
    async remove(email) { await db.delete(pgUsers).where(eq(pgUsers.email, email)); },
  };
}
export function libsqlUsers<TSchema extends Record<string, unknown>>(db: LibSQLDatabase<TSchema>): UsersRepository {
  return {
    async create(user) { await db.insert(sqliteUsers).values(user); },
    async list() { return await db.select().from(sqliteUsers); },
    async setAge(email, age) { await db.update(sqliteUsers).set({ age }).where(eq(sqliteUsers.email, email)); },
    async remove(email) { await db.delete(sqliteUsers).where(eq(sqliteUsers.email, email)); },
  };
}
export async function main(users: UsersRepository) {
  const user: NewUser = { name: 'John', age: 30, email: 'john@example.com' };
  await users.create(user);
  const created = await users.list();
  await users.setAge(user.email, 31);
  const updated = await users.list();
  await users.remove(user.email);
  const remaining = await users.list();
  return { created, updated, remaining };
}

With your existing connections, the entry point becomes:

await main(postgresUsers(devDb));
await main(libsqlUsers(testDb));

There is deliberately no generic (db, table) pair to thread through the shared workflow. TSchema preserves support for connections constructed with an explicitly supplied schema, and each adapter's implementation is checked against the correct dialect. The example makes all three domain fields non-null; adapt the shared domain types if your actual schemas allow nulls or differ in their selected columns.

I checked this on drizzle-orm 0.45.3 / TypeScript 5.9.3 with strict type checking (dependency declaration checking skipped). The same main() performed create/read/update/delete on PGlite for the PostgreSQL dialect and in-memory libSQL for SQLite; both also rejected a duplicate email. Compile-time negative checks rejected passing a SQLite database to postgresUsers() and a PostgreSQL database to libsqlUsers(). The node-postgres connection type was checked too, but I did not run this against an external PostgreSQL server or your repository. Driver setup: PGlite / libSQL.

If SQLite is only a substitute for PostgreSQL in tests, PGlite is still a useful alternative as suggested above. If supporting both dialects is a real requirement, the adapter boundary keeps the business flow shared while letting SQL behavior stay explicit. It does not make SQLite tests proof of PostgreSQL-specific behavior, migrations, or production concurrency.