Framework integration

import 'server-only';
import { better } from 'better-drizzle';
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import { schema } from './schema';

const globalForDb = globalThis as unknown as { pool?: Pool };

const pool =
	globalForDb.pool ?? new Pool({ connectionString: process.env.DATABASE_URL });
if (process.env.NODE_ENV !== 'production') globalForDb.pool = pool;

export const client = better(drizzle(pool, { schema }), { schema });

import { client } from '@/lib/db';
import { toHttpError } from '@/lib/http-error';

export async function GET(
	request: Request,
	{ params }: { params: Promise<{ id: string }> },
) {
	const { id } = await params;
	const db = client.$withContext({
		requestId: request.headers.get('x-request-id') ?? crypto.randomUUID(),
	});

	try {
		const user = await db.users
			.findUnique({ where: { id: Number(id) } })
			.throw();

		return Response.json(user);
	} catch (error) {
		const { status, body } = toHttpError(error);
		return Response.json(body, { status });
	}
}

'use server';

import { headers } from 'next/headers';
import { client } from '@/lib/db';

export async function createPost(input: { authorId: number; title: string }) {
	const requestHeaders = await headers();
	const db = client.$withContext({
		requestId: requestHeaders.get('x-request-id') ?? crypto.randomUUID(),
		userId: input.authorId,
	});

	return db.transaction(
		(tx) =>
			tx.posts.create({
				data: { authorId: input.authorId, title: input.title, published: false },
			}),
		{ timeoutMs: 5_000 },
	);
}

import { Hono } from 'hono';
import { client, type Db } from './lib/db';
import { toHttpError } from './lib/http-error';

const app = new Hono<{ Variables: { db: Db } }>();

app.use(async (c, next) => {
	c.set(
		'db',
		client.$withContext({
			requestId: c.req.header('x-request-id') ?? crypto.randomUUID(),
			tenantId: c.req.header('x-tenant-id'),
		}),
	);
	await next();
});

app.get('/users/:id', async (c) => {
	const user = await c
		.get('db')
		.users.findUnique({ where: { id: Number(c.req.param('id')) } })
		.throw();

	return c.json(user);
});

app.onError((error) => {
	const { status, body } = toHttpError(error);
	return Response.json(body, { status });
});

export default app;

import express from 'express';
import { client, type Db } from './lib/db';
import { toHttpError } from './lib/http-error';

declare global {
	namespace Express {
		interface Locals {
			db: Db;
		}
	}
}

const app = express();

app.use((req, res, next) => {
	res.locals.db = client.$withContext({
		requestId: req.header('x-request-id') ?? crypto.randomUUID(),
	});
	next();
});

app.get('/users/:id', async (req, res) => {
	const user = await res.locals.db.users
		.findUnique({ where: { id: Number(req.params.id) } })
		.throw();

	res.json(user);
});

app.use(
	(
		error: unknown,
		req: express.Request,
		res: express.Response,
		next: express.NextFunction,
	) => {
		const { status, body } = toHttpError(error);
		res.status(status).json(body);
	},
);

import Fastify from 'fastify';
import { client, type Db } from './lib/db';
import { toHttpError } from './lib/http-error';

declare module 'fastify' {
	interface FastifyRequest {
		db: Db;
	}
}

const app = Fastify();

app.decorateRequest('db', null as unknown as Db);

app.addHook('onRequest', async (request) => {
	request.db = client.$withContext({ requestId: request.id });
});

app.get<{ Params: { id: string } }>('/users/:id', async (request) =>
	request.db.users
		.findUnique({ where: { id: Number(request.params.id) } })
		.throw(),
);

app.setErrorHandler((error, request, reply) => {
	const { status, body } = toHttpError(error);
	reply.status(status).send(body);
});