Turso + Drizzle ORM으로 테넌트별 독립 SQLite DB를 엣지에서 운영하는 법

SQLite (파일 기반, 단일 머신)
    ↓ fork + 네트워크 레이어 추가
libSQL (오픈소스, HTTP 프로토콜 지원)
    ↓ 관리형 서비스화
Turso (Fly.io 기반, 30+ 리전)

// ❌ Node.js 환경 전용 — Workers에서 동작 안 함
import { createClient } from '@libsql/client';
 
// ✅ Cloudflare Workers / 엣지 환경
import { createClient } from '@libsql/client/web';

pnpm add drizzle-orm @libsql/client hono
pnpm add -D drizzle-kit wrangler @tursodatabase/api

name = "my-saas-worker"
main = "src/index.ts"
compatibility_date = "2025-01-01"
 
[vars]
META_DB_URL = "libsql://meta-db-org.turso.io"
 
[[kv_namespaces]]
binding = "TENANT_CACHE"
id = "your-kv-namespace-id"
 
# 시크릿은 wrangler secret put으로 설정
# META_DB_AUTH_TOKEN

// src/schema/meta.ts — 테넌트 레지스트리
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
 
export const tenants = sqliteTable('tenants', {
  id: text('id').primaryKey(), // 테넌트 슬러그 (예: 'acme-corp')
  dbUrl: text('db_url').notNull(),
  dbAuthToken: text('db_auth_token').notNull(), // ⚠️ 아래 보안 주의사항 참고
  plan: text('plan').notNull().default('free'),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
});

// src/schema/tenant.ts — 각 테넌트 DB 스키마
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
 
export const users = sqliteTable('users', {
  id: text('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name'),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
});
 
export const projects = sqliteTable('projects', {
  id: text('id').primaryKey(),
  name: text('name').notNull(),
  ownerId: text('owner_id').notNull().references(() => users.id),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
});

// drizzle.config.ts — 메타 DB 마이그레이션
import { defineConfig } from 'drizzle-kit';
 
export default defineConfig({
  dialect: 'turso',
  schema: './src/schema/meta.ts',
  out: './drizzle/meta',
  dbCredentials: {
    url: process.env.META_DB_URL!,
    authToken: process.env.META_DB_AUTH_TOKEN!,
  },
});

// drizzle.tenant.config.ts — 테넌트 DB 마이그레이션
import { defineConfig } from 'drizzle-kit';
 
export default defineConfig({
  dialect: 'turso',
  schema: './src/schema/tenant.ts',
  out: './drizzle/tenant',
  dbCredentials: {
    url: process.env.TENANT_DB_URL!,
    authToken: process.env.TENANT_DB_AUTH_TOKEN!,
  },
});

// scripts/provision-tenant.ts
// Node.js / Bun 환경에서 실행 (Workers 아님)
import { createClient } from '@libsql/client';
import { TursoClient } from '@tursodatabase/api';
import { drizzle } from 'drizzle-orm/libsql';
import { migrate } from 'drizzle-orm/libsql/migrator';
import { tenants } from '../src/schema/meta';
 
export async function provisionTenant(
  metaDb: ReturnType<typeof drizzle>,
  turso: TursoClient,
  tenantId: string,
) {
  // 1. Turso Platform API로 새 DB 생성
  const db = await turso.databases.create({
    name: `tenant-${tenantId}`,
    group: 'default',
  });
 
  // 2. Auth Token 발급
  // 프로퍼티 이름(db.name, db.hostname 등)은 @tursodatabase/api 버전마다
  // 다를 수 있으니 설치 후 타입 정의를 직접 확인하세요.
  const token = await turso.databases.createToken(db.name);
 
  const dbUrl = `libsql://${db.hostname}`;
  const dbAuthToken = token.jwt;
 
  // 3. 새 DB에 스키마 마이그레이션 적용
  const tenantClient = createClient({ url: dbUrl, authToken: dbAuthToken });
  const tenantDrizzle = drizzle(tenantClient);
 
  await migrate(tenantDrizzle, { migrationsFolder: './drizzle/tenant' });
 
  // 4. 메타 DB에 테넌트 정보 등록 (프로덕션에서는 토큰 암호화 후 저장)
  await metaDb.insert(tenants).values({
    id: tenantId,
    dbUrl,
    dbAuthToken,
    plan: 'free',
    createdAt: new Date(),
  });
 
  return { dbUrl, dbAuthToken };
}

// src/index.ts
import { Hono } from 'hono';
import { drizzle } from 'drizzle-orm/libsql';
import { createClient } from '@libsql/client/web'; // Workers에서는 반드시 /web
import { eq } from 'drizzle-orm';
import { tenants } from './schema/meta';
import { users, projects } from './schema/tenant';
 
type Env = {
  Bindings: {
    META_DB_URL: string;
    META_DB_AUTH_TOKEN: string;
    TENANT_CACHE: KVNamespace;
  };
  Variables: {
    tenantDb: ReturnType<typeof drizzle>;
  };
};
 
const app = new Hono<Env>();
 
// 테넌트 미들웨어 — KV 캐시 → 메타 DB 순서로 조회
app.use('/api/*', async (c, next) => {
  const tenantId = c.req.header('X-Tenant-ID');
  if (!tenantId) return c.json({ error: 'Tenant ID required' }, 400);
 
  let dbUrl: string;
  let dbAuthToken: string;
 
  // 1. KV 캐시 먼저 확인
  const cached = await c.env.TENANT_CACHE.get(tenantId);
  if (cached) {
    ({ dbUrl, dbAuthToken } = JSON.parse(cached));
  } else {
    // 2. 캐시 미스 시 메타 DB 조회
    const metaClient = createClient({
      url: c.env.META_DB_URL,
      authToken: c.env.META_DB_AUTH_TOKEN,
    });
    const metaDb = drizzle(metaClient);
 
    const [tenant] = await metaDb
      .select()
      .from(tenants)
      .where(eq(tenants.id, tenantId))
      .limit(1);
 
    if (!tenant) return c.json({ error: 'Tenant not found' }, 404);
 
    dbUrl = tenant.dbUrl;
    dbAuthToken = tenant.dbAuthToken;
 
    // 3. KV에 캐싱 (TTL 60초)
    await c.env.TENANT_CACHE.put(
      tenantId,
      JSON.stringify({ dbUrl, dbAuthToken }),
      { expirationTtl: 60 },
    );
  }
 
  const tenantClient = createClient({ url: dbUrl, authToken: dbAuthToken });
  c.set('tenantDb', drizzle(tenantClient));
 
  await next();
});
 
app.get('/api/users', async (c) => {
  const db = c.get('tenantDb');
  const result = await db.select().from(users);
  return c.json(result);
});
 
app.post('/api/projects', async (c) => {
  const db = c.get('tenantDb');
  const body = await c.req.json<{ name: string; ownerId: string }>();
 
  const [project] = await db
    .insert(projects)
    .values({
      id: crypto.randomUUID(),
      name: body.name,
      ownerId: body.ownerId,
      createdAt: new Date(),
    })
    .returning();
 
  return c.json(project, 201);
});
 
export default app;

// Workers에서 이걸 쓰면 배포 후 런타임 에러
import { createClient } from '@libsql/client';
 
// 이걸 써야 합니다
import { createClient } from '@libsql/client/web';