Build a Type-Safe API with Elysia and Drizzle on Bun

# Initialize Bun project
bun init my-api
cd my-api

# Install dependencies
bun add elysia @elysiajs/cors @elysiajs/swagger @elysiajs/jwt
bun add drizzle-orm postgres
bun add -D drizzle-kit @types/bun

// drizzle.config.ts — Drizzle Kit configuration
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  dialect: "postgresql",
  schema: "./src/db/schema.ts",
  out: "./drizzle",
  dbCredentials: {
    url: process.env.DATABASE_URL!,
  },
});

// src/db/schema.ts — Database schema = type source of truth
/**
 * All application types flow from this file.
 * Drizzle infers TypeScript types from the schema.
 * No separate interface files needed.
 */
import {
  pgTable, uuid, text, timestamp, boolean, integer, pgEnum, index,
} from "drizzle-orm/pg-core";
import { relations, InferSelectModel, InferInsertModel } from "drizzle-orm";

export const roleEnum = pgEnum("role", ["user", "admin"]);

export const users = pgTable("users", {
  id: uuid("id").primaryKey().defaultRandom(),
  email: text("email").notNull().unique(),
  name: text("name").notNull(),
  role: roleEnum("role").default("user").notNull(),
  passwordHash: text("password_hash").notNull(),
  createdAt: timestamp("created_at").defaultNow().notNull(),
}, (t) => ([index("users_email_idx").on(t.email)]));

export const projects = pgTable("projects", {
  id: uuid("id").primaryKey().defaultRandom(),
  name: text("name").notNull(),
  description: text("description"),
  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
  isPublic: boolean("is_public").default(false).notNull(),
  starCount: integer("star_count").default(0).notNull(),
  createdAt: timestamp("created_at").defaultNow().notNull(),
  updatedAt: timestamp("updated_at").defaultNow().notNull(),
}, (t) => ([
  index("projects_owner_idx").on(t.ownerId),
]));

// Relations
export const usersRelations = relations(users, ({ many }) => ({
  projects: many(projects),
}));

export const projectsRelations = relations(projects, ({ one }) => ({
  owner: one(users, { fields: [projects.ownerId], references: [users.id] }),
}));

// Inferred types — used everywhere, defined nowhere manually
export type User = InferSelectModel<typeof users>;
export type NewUser = InferInsertModel<typeof users>;
export type Project = InferSelectModel<typeof projects>;
export type NewProject = InferInsertModel<typeof projects>;

// src/db/index.ts — Database connection
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";
import * as schema from "./schema";

const client = postgres(process.env.DATABASE_URL!);
export const db = drizzle(client, { schema });

# Generate and apply initial migration
bunx drizzle-kit generate
bunx drizzle-kit migrate

// src/index.ts — Main Elysia app with typed routes
import { Elysia, t } from "elysia";
import { cors } from "@elysiajs/cors";
import { swagger } from "@elysiajs/swagger";
import { jwt } from "@elysiajs/jwt";
import { db } from "./db";
import { users, projects } from "./db/schema";
import { eq } from "drizzle-orm";

const app = new Elysia()
  .use(cors())
  .use(swagger({ documentation: { info: { title: "My SaaS API", version: "1.0.0" } } }))
  .use(jwt({ name: "jwt", secret: process.env.JWT_SECRET! }))

  // Auth derive — available to all routes below
  .derive(async ({ jwt, headers }) => {
    const token = headers.authorization?.replace("Bearer ", "");
    if (!token) return { user: null };
    const payload = await jwt.verify(token);
    return { user: payload as { id: string; email: string; role: string } | null };
  })

  // Auth routes
  .post("/auth/register", async ({ body, jwt }) => {
    const passwordHash = await Bun.password.hash(body.password);
    const [user] = await db.insert(users).values({
      email: body.email,
      name: body.name,
      passwordHash,
    }).returning({ id: users.id, email: users.email, name: users.name, role: users.role });

    const token = await jwt.sign({ id: user.id, email: user.email, role: user.role });
    return { user, token };
  }, {
    body: t.Object({
      email: t.String({ format: "email" }),
      name: t.String({ minLength: 2 }),
      password: t.String({ minLength: 8 }),
    }),
  })

  .post("/auth/login", async ({ body, jwt, error }) => {
    const [user] = await db.select().from(users).where(eq(users.email, body.email)).limit(1);
    if (!user) return error(401, { message: "Invalid credentials" });

    const valid = await Bun.password.verify(body.password, user.passwordHash);
    if (!valid) return error(401, { message: "Invalid credentials" });

    const token = await jwt.sign({ id: user.id, email: user.email, role: user.role });
    return { token };
  }, {
    body: t.Object({
      email: t.String({ format: "email" }),
      password: t.String(),
    }),
  })

  // Project CRUD
  .get("/projects", async ({ query }) => {
    const result = await db.query.projects.findMany({
      where: query.public ? eq(projects.isPublic, true) : undefined,
      with: { owner: { columns: { id: true, name: true } } },
      limit: query.limit,
      offset: (query.page - 1) * query.limit,
    });
    return { projects: result, page: query.page, limit: query.limit };
  }, {
    query: t.Object({
      page: t.Number({ default: 1 }),
      limit: t.Number({ default: 20, maximum: 100 }),
      public: t.Optional(t.Boolean()),
    }),
  })

  .post("/projects", async ({ body, user, error }) => {
    if (!user) return error(401, { message: "Authentication required" });

    const [project] = await db.insert(projects).values({
      ...body,
      ownerId: user.id,
    }).returning();

    return project;
  }, {
    body: t.Object({
      name: t.String({ minLength: 1, maxLength: 100 }),
      description: t.Optional(t.String({ maxLength: 1000 })),
      isPublic: t.Optional(t.Boolean()),
    }),
  })

  .get("/projects/:id", async ({ params, error }) => {
    const project = await db.query.projects.findFirst({
      where: eq(projects.id, params.id),
      with: { owner: { columns: { id: true, name: true, email: true } } },
    });
    if (!project) return error(404, { message: "Project not found" });
    return project;
  }, {
    params: t.Object({ id: t.String({ format: "uuid" }) }),
  })

  .listen(3000);

console.log(`🦊 API running at ${app.server?.url}`);

// Export type for Eden Treaty client
export type App = typeof app;

// client/api.ts — Fully typed API client
/**
 * Zero codegen. The client types are inferred directly from the
 * Elysia app type. Change a route on the server → client
 * gets a compile error immediately.
 */
import { treaty } from "@elysiajs/eden";
import type { App } from "../src/index";

export const api = treaty<App>("localhost:3000");

// Usage — everything is typed
async function demo() {
  // Register
  const { data: auth } = await api.auth.register.post({
    email: "juri@example.com",
    name: "Juri",
    password: "secure-password-123",
  });
  // auth.token, auth.user.id — all typed

  // List projects with pagination
  const { data: projects } = await api.projects.get({
    query: { page: 1, limit: 10, public: true },
  });
  // projects.projects[0].name — typed from Drizzle schema

  // Create project (with auth header)
  const { data: newProject } = await api.projects.post(
    { name: "My Project", description: "Built with Elysia + Drizzle" },
    { headers: { authorization: `Bearer ${auth!.token}` } }
  );
  // newProject.id — UUID from Drizzle schema

  // Get single project
  const { data: project } = await api.projects({ id: newProject!.id }).get();
  // project.owner.name — typed through Drizzle relation
}