Building without available db connection

[ValentinBilla]

Hi everyone, I am having a hard time making a SvelteKit app compile using drizzle-orm.

By my understanding, drizzle requires a connection to the database even at build time, as I would like to create a docker image this is quite a hassle to provide during the build stage.

Is there any way to gracefully skip the database connection ?

I tried creating a mock db (by creating an undefined client that I type as a MySQL2Client forcefully) whenever NODE_ENV is build but this only results in other errors down the line as the db is of course not functionnal.

One person on stack overflow decided to simply set the db to null and thereafter put a condition in each and everyone of his db functions eg.

async function findAllUsers(): Promise<User[]> {
    if (db === null) return []
    return db.select().from(table.user);
}

Which I guess is functionnal but leaves me thinking that there must be a better way.

[AxelFranz]

Hi, did you find a better way since ? I'm having the same issue

[AbdullahMaqbool22]

Drizzle itself doesn't open a connection at build time, drizzle() just wraps the underlying driver client, and the common clients (mysql2, postgres.js, node-postgres) are lazy: they don't actually hit the database until the first query runs. So if your build is actually failing, it's one of two things, not Drizzle requiring a live connection:

1. The driver's client constructor throws synchronously when something is missing or malformed. mysql2.createPool(url) / postgres(url) parse the connection string immediately, even though they won't connect until a query runs, so an undefined or malformed DATABASE_URL at build time throws right there.
2. 2. Something in your SvelteKit build is actually executing a load function that queries the db. This is almost always because a route (or your root +layout) is being prerendered, SvelteKit's vite build runs load functions at build time to produce static HTML for any route marked prerender = true (or a default adapter config that prerenders everything it can).
      Two fixes, used together, remove the need for the build-time mock client or the db === null checks entirely:

A. Read the DB URL with $env/dynamic/private, not $env/static/private. Static env vars get inlined and validated during the Vite build; dynamic ones are read from process.env at request time, so your db module needs no real value while building:

// db.ts
import { env } from '$env/dynamic/private';
import { drizzle } from 'drizzle-orm/mysql2';
import mysql from 'mysql2/promise';

const pool = mysql.createPool(env.DATABASE_URL);
export const db = drizzle(pool);

B. Make sure nothing that touches db is prerendered. Check your root +layout.(server.)ts and any route whose load queries the database for a stray export const prerender = true, and set it to false (or just remove it, SSR-on-request is the default unless you opt into prerendering).

With both in place, vite build never instantiates a real connection and never calls a db-backed load function, so your Docker build stage needs no DATABASE_URL and no reachable database at all, just the app code.

[Lumichandesu]

One missing piece in the example above: $env/dynamic/private doesn't defer mysql.createPool(...). That call still runs when the module is imported. SvelteKit imports route modules and their dependencies during build analysis, even without prerendering.

For a SvelteKit 2 setup using that env API, I'd defer initialization itself with a cached getter:

// src/lib/server/db.ts
import { env } from '$env/dynamic/private';
import { drizzle } from 'drizzle-orm/mysql2';
import mysql from 'mysql2/promise';

function createDb() {
  const url = env.DATABASE_URL;
  if (!url) throw new Error('DATABASE_URL is required at runtime');
  return drizzle({ client: mysql.createPool(url) });
}

let db: ReturnType<typeof createDb> | undefined;

export function getDb() {
  return (db ??= createDb());
}

Call getDb().select()... inside server load functions/actions, not at module scope. Importing this module then doesn't read DATABASE_URL or construct the pool, and the null checks stay out of every query function. Drizzle documents using a mysql2 pool as the client.

Database-backed prerendering still needs a database during the build; this only addresses initialization during module analysis. This is a docs-based suggestion, not a reproduction against your app, so if it still fails, the build stack trace would help distinguish initialization from an actual build-time query.