Vercel Postgres is no longer available. New projects use a Postgres provider from Marketplace. Other providers have their own connection setup.
Drizzle with Postgres on Vercel
This tutorial uses the Drizzle ORM and Drizzle Kit v1 release candidate to set up a new project with Postgres on Vercel. For this example, we use a Neon database connected through Vercel Marketplace.
- Use Node.js 22 or later for the Neon serverless driver.
- You should have installed Drizzle ORM and Drizzle kit. You can do this by running the following command:
npm i drizzle-orm@rc
npm i -D drizzle-kit@rc
- You should have installed
dotenvpackage for managing environment variables. Read more about this package here
npm i dotenv
- You should have installed
@neondatabase/serverlesspackage. Read more about this package here
npm i @neondatabase/serverless
Setup Neon on Vercel and Drizzle ORM
Create and connect a Neon database
Add Neon from Vercel Marketplace to your Vercel project. Follow the integration’s setup to create a database and connect it to the project.
Setup the connection string
The integration adds database environment variables to the connected project. Link your local directory and download the development variables:
npx vercel link
npx vercel env pull .env.localConfirm that .env.local contains DATABASE_URL. If you configured a prefix for the integration, use the corresponding variable name throughout this tutorial. Keep this file out of version control.
DATABASE_URL=<YOUR_NEON_DATABASE_URL>Connect Drizzle ORM to your database
Create a index.ts file in the src/db directory and set up your database configuration:
import { drizzle } from 'drizzle-orm/neon-http';
import { neon } from '@neondatabase/serverless';
import { config } from 'dotenv';
config({ path: '.env.local' });
const sql = neon(process.env.DATABASE_URL!);
export const db = drizzle({ client: sql });Create tables
Create a schema.ts file in the src/db directory and declare your tables:
import { integer, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
export const usersTable = pgTable('users_table', {
id: serial('id').primaryKey(),
name: text('name').notNull(),
age: integer('age').notNull(),
email: text('email').notNull().unique(),
});
export const postsTable = pgTable('posts_table', {
id: serial('id').primaryKey(),
title: text('title').notNull(),
content: text('content').notNull(),
userId: integer('user_id')
.notNull()
.references(() => usersTable.id, { onDelete: 'cascade' }),
createdAt: timestamp('created_at').notNull().defaultNow(),
updatedAt: timestamp('updated_at')
.notNull()
.$onUpdate(() => new Date()),
});
export type InsertUser = typeof usersTable.$inferInsert;
export type SelectUser = typeof usersTable.$inferSelect;
export type InsertPost = typeof postsTable.$inferInsert;
export type SelectPost = typeof postsTable.$inferSelect;Setup Drizzle config file
Drizzle config - a configuration file that is used by Drizzle Kit and contains all the information about your database connection, migration folder and schema files.
Create a drizzle.config.ts file in the root of your project and add the following content:
import { config } from 'dotenv';
import { defineConfig } from 'drizzle-kit';
config({ path: '.env.local' });
export default defineConfig({
schema: './src/db/schema.ts',
out: './migrations',
dialect: 'postgresql',
dbCredentials: {
url: process.env.DATABASE_URL!,
},
});Applying changes to the database
You can generate migrations using drizzle-kit generate command and then run them using the drizzle-kit migrate command.
Generate migrations:
npx drizzle-kit generateThese migrations are stored in the migrations directory, as specified in your drizzle.config.ts. Each migration has its own timestamped folder containing migration.sql and snapshot.json.
Example of a generated migration:
CREATE TABLE "posts_table" (
"id" serial PRIMARY KEY,
"title" text NOT NULL,
"content" text NOT NULL,
"user_id" integer NOT NULL,
"created_at" timestamp DEFAULT now() NOT NULL,
"updated_at" timestamp NOT NULL
);
--> statement-breakpoint
CREATE TABLE "users_table" (
"id" serial PRIMARY KEY,
"name" text NOT NULL,
"age" integer NOT NULL,
"email" text NOT NULL UNIQUE
);
--> statement-breakpoint
ALTER TABLE "posts_table" ADD CONSTRAINT "posts_table_user_id_users_table_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users_table"("id") ON DELETE CASCADE;Run migrations:
npx drizzle-kit migrateAlternatively, you can push changes directly to the database using Drizzle kit push command:
npx drizzle-kit pushBasic file structure
The src/db directory contains the connection in index.ts and table definitions in schema.ts. Drizzle Kit writes migrations to migrations. Your generated migration timestamp and name will differ from this example.
📦 <project root>
├ 📂 src
│ ├ 📂 db
│ │ ├ 📜 index.ts
│ │ └ 📜 schema.ts
├ 📂 migrations
│ └ 📂 20261117000000_initial
│ ├ 📜 migration.sql
│ └ 📜 snapshot.json
├ 📜 .env.local
├ 📜 drizzle.config.ts
├ 📜 package.json
└ 📜 tsconfig.jsonQuery examples
For instance, we create src/db/queries folder and separate files for each operation: insert, select, update, delete.
Insert data
Read more about insert query in the documentation.
import { db } from '../index';
import { InsertPost, InsertUser, postsTable, usersTable } from '../schema';
export async function createUser(data: InsertUser) {
await db.insert(usersTable).values(data);
}
export async function createPost(data: InsertPost) {
await db.insert(postsTable).values(data);
}Select data
Read more about select query in the documentation.
Use getColumns(usersTable) to include all user columns alongside the computed post count in the second query below.
import { asc, between, count, eq, getColumns, sql } from 'drizzle-orm';
import { db } from '../index';
import { SelectUser, postsTable, usersTable } from '../schema';
export async function getUserById(id: SelectUser['id']): Promise<
Array<{
id: number;
name: string;
age: number;
email: string;
}>
> {
return db.select().from(usersTable).where(eq(usersTable.id, id));
}
export async function getUsersWithPostsCount(
page = 1,
pageSize = 5,
): Promise<
Array<{
postsCount: number;
id: number;
name: string;
age: number;
email: string;
}>
> {
return db
.select({
...getColumns(usersTable),
postsCount: count(postsTable.id),
})
.from(usersTable)
.leftJoin(postsTable, eq(usersTable.id, postsTable.userId))
.groupBy(usersTable.id)
.orderBy(asc(usersTable.id))
.limit(pageSize)
.offset((page - 1) * pageSize);
}
export async function getPostsForLast24Hours(
page = 1,
pageSize = 5,
): Promise<
Array<{
id: number;
title: string;
}>
> {
return db
.select({
id: postsTable.id,
title: postsTable.title,
})
.from(postsTable)
.where(between(postsTable.createdAt, sql`now() - interval '1 day'`, sql`now()`))
.orderBy(asc(postsTable.title), asc(postsTable.id))
.limit(pageSize)
.offset((page - 1) * pageSize);
}Alternatively, you can use relational query syntax.
Update data
Read more about update query in the documentation.
import { eq } from 'drizzle-orm';
import { db } from '../index';
import { SelectPost, postsTable } from '../schema';
export async function updatePost(id: SelectPost['id'], data: Partial<Omit<SelectPost, 'id'>>) {
await db.update(postsTable).set(data).where(eq(postsTable.id, id));
}Delete data
Read more about delete query in the documentation.
import { eq } from 'drizzle-orm';
import { db } from '../index';
import { SelectUser, usersTable } from '../schema';
export async function deleteUser(id: SelectUser['id']) {
await db.delete(usersTable).where(eq(usersTable.id, id));
}