Bun 1.2 내장 SQLite로 구성하는 Zero-Dependency 로컬 우선 백엔드

// bun:sqlite는 별도 설치 없이 바로 import됩니다
import { Database } from "bun:sqlite";
 
const db = new Database("app.db");
db.run("PRAGMA journal_mode=WAL");
db.run("PRAGMA busy_timeout = 5000");

const insertMany = db.transaction((users: Array<{ name: string; email: string }>) => {
  const insert = db.prepare("INSERT INTO users (name, email) VALUES (?, ?)");
  for (const user of users) {
    insert.run(user.name, user.email);
  }
});
 
insertMany([
  { name: "Alice", email: "alice@example.com" },
  { name: "Bob", email: "bob@example.com" },
]);

// src/schema.ts
import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
 
export const users = sqliteTable("users", {
  id: integer("id").primaryKey({ autoIncrement: true }),
  name: text("name").notNull(),
  email: text("email").notNull().unique(),
  createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => new Date()),
});
 
export const posts = sqliteTable("posts", {
  id: integer("id").primaryKey({ autoIncrement: true }),
  title: text("title").notNull(),
  content: text("content"),
  authorId: integer("author_id").references(() => users.id),
});

// src/db.ts
import { Database } from "bun:sqlite";
import { drizzle } from "drizzle-orm/bun-sqlite";
import * as schema from "./schema";
 
const sqlite = new Database("app.db");
sqlite.run("PRAGMA journal_mode=WAL");
sqlite.run("PRAGMA busy_timeout = 5000");
 
export const db = drizzle(sqlite, { schema });

import { eq, desc } from "drizzle-orm";
import { db } from "./db";
import { users, posts } from "./schema";
 
// SQL-like API — SELECT 절이 그대로 보입니다
const recentPosts = await db
  .select()
  .from(posts)
  .orderBy(desc(posts.id))
  .limit(10);
 
// Relational API — with 절로 관계 데이터를 가져옵니다
const userWithPosts = await db.query.users.findFirst({
  where: eq(users.id, 1),
  with: { posts: true },
});
// userWithPosts의 타입은 완전히 추론됩니다

// src/index.ts
import { Hono } from "hono";
import { logger } from "hono/logger";
import { HTTPException } from "hono/http-exception";
import { postsRoute } from "./routes/posts";
 
const app = new Hono();
 
app.use("*", logger());
app.route("/api/posts", postsRoute);
 
app.onError((err, c) => {
  if (err instanceof HTTPException) {
    return err.getResponse();
  }
  console.error(err);
  return c.json({ error: "Internal server error" }, 500);
});
 
export default {
  port: Number(process.env.PORT ?? 3000),
  fetch: app.fetch,
};

bun init -y
bun add hono drizzle-orm @hono/zod-validator zod
bun add -d drizzle-kit

import type { Config } from "drizzle-kit";
 
export default {
  schema: "./src/schema.ts",
  out: "./drizzle",
  dialect: "sqlite",
  dbCredentials: {
    url: "./app.db",
  },
} satisfies Config;

// src/db.ts에 추가
import { migrate } from "drizzle-orm/bun-sqlite/migrator";
 
migrate(db, { migrationsFolder: "./drizzle" });

// src/routes/posts.ts
import { Hono } from "hono";
import { HTTPException } from "hono/http-exception";
import { zValidator } from "@hono/zod-validator";
import { z } from "zod";
import { db } from "../db";
import { posts, users } from "../schema";
import { eq, desc } from "drizzle-orm";
 
const postsRoute = new Hono();
 
const createPostSchema = z.object({
  title: z.string().min(1).max(200),
  content: z.string().optional(),
  authorId: z.number().int().positive(),
});
 
postsRoute.get("/", async (c) => {
  const page = Number(c.req.query("page") ?? "1");
  const limit = 20;
  const offset = (page - 1) * limit;
 
  const result = await db
    .select({
      id: posts.id,
      title: posts.title,
      authorName: users.name,
    })
    .from(posts)
    .leftJoin(users, eq(posts.authorId, users.id))
    .orderBy(desc(posts.id))
    .limit(limit)
    .offset(offset);
 
  return c.json(result);
});
 
postsRoute.post("/", zValidator("json", createPostSchema), async (c) => {
  const body = c.req.valid("json");
 
  const result = await db.transaction(async (tx) => {
    const author = await tx
      .select()
      .from(users)
      .where(eq(users.id, body.authorId))
      .get();
 
    if (!author) {
      // 작성자가 없는 건 클라이언트 오류입니다 — 500이 아니라 404를 반환합니다
      throw new HTTPException(404, { message: "Author not found" });
    }
 
    const [post] = await tx.insert(posts).values(body).returning();
    return post;
  });
 
  return c.json(result, 201);
});
 
export { postsRoute };

# litestream.yml
dbs:
  - path: /app/app.db
    replicas:
      - type: s3
        bucket: my-backup-bucket
        path: db
        region: ap-northeast-2

# Dockerfile
FROM oven/bun:1.2-slim
 
WORKDIR /app
COPY package.json bun.lock ./
RUN bun install --frozen-lockfile
 
COPY . .
RUN bun run build   # drizzle-kit generate가 포함된 경우
 
# Litestream 바이너리를 함께 복사
COPY --from=litestream/litestream:latest /usr/local/bin/litestream /usr/local/bin/
 
EXPOSE 3000
# -exec 플래그: Litestream이 앱 프로세스를 자식 프로세스로 관리합니다.
# 앱이 충돌하면 Litestream도 종료되고 컨테이너가 재시작됩니다.
CMD ["litestream", "replicate", "-exec", "bun src/index.ts", "litestream.yml"]

# 1. 프로젝트 생성
bun init -y
bun add hono drizzle-orm @hono/zod-validator zod
bun add -d drizzle-kit
 
# 2. 스키마 작성 후 개발 DB 초기화
bunx drizzle-kit push
 
# 3. 서버 실행
bun src/index.ts

bunx drizzle-kit generate   # 마이그레이션 파일 생성
git add drizzle/             # 버전 관리에 포함
# 배포 시 앱 시작 전 migrate() 함수가 자동 적용