Unified Drizzle driver

[AlexBlokh]

To run queries on your database Drizzle uses database drivers like node-postgres or postgresjs. It requires you to import and initialise driver and then pass to drizzle init funciton:

import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

const client = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(client);

the problem with the above is also esm and cjs, if you'd be using node-postgres in esm, you'd have to:

import { drizzle } from "drizzle-orm/node-postgres";
import pg from "pg";

const client = new pg.Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(client);

otherwise it would break and while it's technically not Drizzle - this degrades the overall DX

Our initial intention with unified driver was to have a prettier, more concise API and to reduce entrance friction for newcomers who are not very familiar with what database drivers are.

You'd be able to just:

import { drizzle } from "drizzle-orm/connect";

const db = await drizzle("node-postgres", process.env.DATABASE_URL);

we've implemented this API in our recent release and it turned out this API is doomed

Because of the underlying implementation with dynamic imports - init method had to be promisified, which is a decent downgrade, yet we thought it'd be ok with all the benefits we'd have. It had to live in /connect module, since it turns out otherwise it will break the ability to use Drizzle in NextJS project because webpack tries to bundle all dynamic ./.. imports into the bundle and our dynamic imports in connect module are referencing database driver libraries. Later we've found out that our current implementation of monodriver is completely unbundable unless you will explicitly tell bundler all the database drivers to be external dependencies except the one you need

while api looks great - it is obvious now we will have to get rid of it, otherwise it will degrade DX and it will be a massive maintenance burden

We decided to not throw everything away and came up with a compromised idea to boost our original API taking in count all the experience we've gained with monodriver:

was:

import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

const client = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(client);

now:

import { drizzle } from "drizzle-orm/node-postgres";

const db = drizzle(process.env.DATABASE_URL);
// or
const db = drizzle({
  connection: process.env.DATABASE_URL
});
const db = drizzle({
  connection: {
    user: "...",
    password: "...",
    host: "...",
    port: 4321,
    db: "...",
  },
});

// if you need to pass logger or schema
const db = drizzle({
  connection: process.env.DATABASE_URL,
  logger: true,
  schema: schema,
});

in order to not introduce breaking change - we will still leave support for deprecated API until V1 release. It will degrade autocomplete performance in connection params due to DatabaseDriver | ConnectionParams types collision, but that's a decent compromise against breaking changes

import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

const client = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(client); // deprecated but available

// new version
const db = drizzle({
  client: client,
});

This way we can also eliminate problems like one mentioned above, when we're now creating driver for the user and since we bundle ORM both for cjs and esm.

[JakeGinnivan]

If you can make sure ConnectionParams supports the function type for password if the plan is to remove the driver being passed.

It's essential for using Managed Identity and other access token based auth to the DB.

[naz]

What would be the current best practice for initialization logic like this one?

import 'dotenv/config';
import { drizzle } from 'drizzle-orm/connect';
import { seed } from './seed';

const driver =
  process.env.NODE_ENV === 'production' ? 'neon-http' : 'node-postgres';

async function main() {
  const db = await drizzle(driver, process.env.POSTGRES_URL!);
  await seed(db);
}

main();

[m-atthart]

you can programmatically do imports, they don't have to all be done at the top of the file, so i would use that to do the following:

import 'dotenv/config';
import { seed } from './seed';

async function main() {
  const { drizzle } = process.env.NODE_ENV === 'production'
    ? await import('drizzle-orm/neon-http')
    : await import('drizzle-orm/node-postgres');
  
  const db = await drizzle(process.env.DATABASE_URL);
  await seed(db);
}

main();

[mass8326]

Is there any way to close a db connection with this new api?

Previously, as instructed in discussion #228 (comment), we used the driver to close the connection, but now the driver is abstracted away into drizzle.

[kenn]

According to the doc here https://orm.drizzle.team/docs/get-started-postgresql

import { drizzle } from "drizzle-orm/node-postgres"
import { Pool } from "pg"

export const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
})
export const db = drizzle({ client: pool })

or

import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'

export const queryClient = postgres(process.env.DATABASE_URL)
export const db = drizzle({ client: queryClient })