엣지 스택 완벽 가이드: Hono + Turso + Drizzle로 글로벌 저지연 앱 만들기

import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => {
  return c.json({ message: 'Hello from the Edge!' })
})

app.get('/users/:id', async (c) => {
  const id = c.req.param('id')
  // 여기서 DB 조회 (Turso 연결 예정)
  return c.json({ id, name: 'User ' + id })
})

export default app

import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { jwt } from 'hono/jwt'
import { logger } from 'hono/logger'

const app = new Hono()

app.use('*', logger())
app.use('*', cors())

app.use('/api/*', jwt({
  secret: 'YOUR_SECRET'
}))

app.get('/api/protected', (c) => {
  const payload = c.get('jwtPayload')
  return c.json({ user: payload })
})

import { createClient } from '@libsql/client'

const client = createClient({
  url: process.env.TURSO_DATABASE_URL!,
  authToken: process.env.TURSO_AUTH_TOKEN!,
})

const result = await client.execute('SELECT * FROM users WHERE id = ?', [userId])
console.log(result.rows)

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' }).notNull(),
})

export const posts = sqliteTable('posts', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  title: text('title').notNull(),
  content: text('content').notNull(),
  authorId: integer('author_id').references(() => users.id),
  publishedAt: integer('published_at', { mode: 'timestamp' }),
})

import { drizzle } from 'drizzle-orm/libsql'
import { createClient } from '@libsql/client'
import * as schema from './schema'

const client = createClient({
  url: process.env.TURSO_DATABASE_URL!,
  authToken: process.env.TURSO_AUTH_TOKEN!,
})

const db = drizzle(client, { schema })

// 타입 안전 쿼리
const allUsers = await db.select().from(schema.users)
const user = await db.select().from(schema.users).where(eq(schema.users.id, 1))

// 관계 조회
const postsWithAuthors = await db.select()
  .from(schema.posts)
  .leftJoin(schema.users, eq(schema.posts.authorId, schema.users.id))

// src/db/client.ts
import { drizzle } from 'drizzle-orm/libsql'
import { createClient } from '@libsql/client'
import * as schema from './schema'

export const createDb = (env: { DATABASE_URL: string; DATABASE_AUTH_TOKEN: string }) => {
  const client = createClient({
    url: env.DATABASE_URL,
    authToken: env.DATABASE_AUTH_TOKEN,
  })
  return drizzle(client, { schema })
}

// src/routes/users.ts
import { Hono } from 'hono'
import { createDb } from '../db/client'
import { users } from '../db/schema'
import { eq } from 'drizzle-orm'

const app = new Hono()

app.get('/', async (c) => {
  const db = createDb(c.env)
  const allUsers = await db.select().from(users)
  return c.json(allUsers)
})

app.get('/:id', async (c) => {
  const db = createDb(c.env)
  const id = parseInt(c.req.param('id'))
  const user = await db.select().from(users).where(eq(users.id, id))
  
  if (!user.length) {
    return c.json({ error: 'User not found' }, 404)
  }
  
  return c.json(user[0])
})

app.post('/', async (c) => {
  const db = createDb(c.env)
  const { name, email } = await c.req.json()
  
  const newUser = await db.insert(users).values({
    name,
    email,
    createdAt: new Date(),
  }).returning()
  
  return c.json(newUser[0], 201)
})

export default app

// src/index.ts
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { logger } from 'hono/logger'
import usersRoute from './routes/users'
import postsRoute from './routes/posts'

const app = new Hono()

app.use('*', logger())
app.use('*', cors())

app.route('/users', usersRoute)
app.route('/posts', postsRoute)

app.get('/', (c) => {
  return c.json({ 
    message: 'Edge API running!',
    location: c.req.header('cf-ray')?.split('-')[1] || 'unknown'
  })
})

export default app

app.get('/posts/:id', async (c) => {
  const cache = caches.default
  const cacheKey = new Request(c.req.url)
  
  let response = await cache.match(cacheKey)
  
  if (!response) {
    const db = createDb(c.env)
    const post = await db.select().from(posts).where(eq(posts.id, id))
    
    response = new Response(JSON.stringify(post), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'public, max-age=3600',
      },
    })
    
    await cache.put(cacheKey, response.clone())
  }
  
  return response
})

let dbInstance: ReturnType<typeof createDb> | null = null

export const getDb = (env: any) => {
  if (!dbInstance) {
    dbInstance = createDb(env)
  }
  return dbInstance
}

// N+1 문제 회피
const postsWithAuthors = await db
  .select({
    post: posts,
    author: users,
  })
  .from(posts)
  .leftJoin(users, eq(posts.authorId, users.id))
  .limit(10)

// main.ts
import { Hono } from 'hono'
import { serve } from 'https://deno.land/std/http/server.ts'

const app = new Hono()

app.get('/', (c) => c.json({ message: 'Deno Edge!' }))

serve(app.fetch)