RLS 정책 버그 하나가 전 테넌트 데이터를 노출시킬 때 — Turso libSQL의 DB-per-tenant와 Drizzle ORM 동적 연결로 폭발 반경을 줄이는 법

-- 정책은 올바르게 작성됐습니다
ALTER TABLE invoices ENABLE ROW LEVEL SECURITY;
 
CREATE POLICY tenant_isolation ON invoices
  USING (tenant_id = current_setting('app.current_tenant'));

// ORM 레이어에서 세션 변수를 설정합니다
async function getInvoices(tenantId: string) {
  // SET (세션 레벨)을 쓰면 커넥션 풀이 이 커넥션을 재사용할 때
  // 이전 테넌트 값이 그대로 남아있습니다
  await pool.query(`SET app.current_tenant = '${tenantId}'`);
  return pool.query('SELECT * FROM invoices');
}

// app/api/webhooks/clerk/route.ts
import { Webhook } from 'svix';
import { createClient } from '@tursodatabase/api';
 
const turso = createClient({
  org: process.env.TURSO_ORG!,
  token: process.env.TURSO_API_TOKEN!,
});
 
export async function POST(req: Request) {
  const payload = await req.text();
  const headers = {
    'svix-id': req.headers.get('svix-id') ?? '',
    'svix-timestamp': req.headers.get('svix-timestamp') ?? '',
    'svix-signature': req.headers.get('svix-signature') ?? '',
  };
 
  const wh = new Webhook(process.env.CLERK_WEBHOOK_SECRET!);
  let event: ReturnType<typeof wh.verify>;
  try {
    event = wh.verify(payload, headers) as { type: string; data: { id: string } };
  } catch {
    return Response.json({ error: 'Invalid signature' }, { status: 400 });
  }
 
  if (event.type === 'user.created') {
    const userId = event.data.id;
    const dbName = `tenant-${userId.replace(/_/g, '-')}`;
 
    const dbResult = await turso.databases.create(dbName, { group: 'default' });
    // databases.create()가 반환하는 hostname을 직접 사용합니다
    // 문자열 조립으로 URL을 만들면 명명 규칙 변경 시 일관성이 깨집니다
    const hostname = dbResult.hostname;
 
    const tokenResult = await turso.databases.createToken(dbName);
 
    // hostname과 토큰을 함께 저장합니다
    await storeCredentialsForTenant(userId, { hostname, authToken: tokenResult.jwt });
  }
 
  return Response.json({ received: true });
}

// lib/db.ts
import { createClient } from '@libsql/client';
import { drizzle } from 'drizzle-orm/libsql';
import * as schema from './schema';
 
// Node.js 장기 실행 서버에서는 인스턴스를 프로세스 생애주기 동안 재사용합니다
// 서버리스(Vercel Functions, Lambda): 웜 인스턴스에서는 캐시가 유지되지만
//   콜드 스타트마다 초기화됩니다 — 여전히 요청 내 중복 연결은 방지됩니다
// Cloudflare Workers 등 엣지 환경: 요청 간 상태가 없으므로
//   이 Map 캐시가 동작하지 않습니다. 외부 KV나 waitUntil 패턴을 사용하세요
const instanceCache = new Map<string, ReturnType<typeof drizzle>>();
 
export async function getTenantDB(tenantId: string) {
  if (instanceCache.has(tenantId)) {
    return instanceCache.get(tenantId)!;
  }
 
  const { hostname, authToken } = await getCredentialsForTenant(tenantId);
 
  const client = createClient({
    url: `libsql://${hostname}`,
    authToken,
  });
 
  const db = drizzle(client, { schema });
  instanceCache.set(tenantId, db);
  return db;
}

// app/api/invoices/route.ts
import { getTenantDB } from '@/lib/db';
import { invoices } from '@/lib/schema';
import { auth } from '@clerk/nextjs/server';
 
export async function GET() {
  const { userId } = await auth(); // App Router에서 auth()는 비동기입니다
  if (!userId) return Response.json({ error: 'Unauthorized' }, { status: 401 });
 
  // userId가 곧 테넌트 ID — DB 격리라서 tenant_id 필터가 필요 없습니다
  const db = await getTenantDB(userId);
  const result = await db.select().from(invoices);
 
  return Response.json(result);
}

// lib/schema.ts
import { sqliteTable, text, integer, real } from 'drizzle-orm/sqlite-core';
 
export const invoices = sqliteTable('invoices', {
  id: text('id').primaryKey(),
  amount: real('amount').notNull(),
  status: text('status', { enum: ['pending', 'paid', 'overdue'] }).notNull(),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
});
 
export const customers = sqliteTable('customers', {
  id: text('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
});

// scripts/migrate-all-tenants.ts
import { createClient as createTursoApiClient } from '@tursodatabase/api';
import { createClient } from '@libsql/client';
import { drizzle } from 'drizzle-orm/libsql';
import { migrate } from 'drizzle-orm/libsql/migrator';
import pLimit from 'p-limit';
 
const turso = createTursoApiClient({
  org: process.env.TURSO_ORG!,
  token: process.env.TURSO_API_TOKEN!,
});
 
async function migrateAllTenants() {
  const databases = await turso.databases.list();
  // 테넌트 DB만 필터링 — 메타 DB나 다른 용도의 DB가 섞여 있을 수 있습니다
  const tenantDbs = databases.filter((db) => db.name.startsWith('tenant-'));
 
  console.log(`총 ${tenantDbs.length}개 테넌트 DB에 마이그레이션을 실행합니다.`);
 
  const limit = pLimit(20); // 동시 20개로 제한
 
  const results = await Promise.allSettled(
    tenantDbs.map((db) =>
      limit(async () => {
        const tokenResult = await turso.databases.createToken(db.name);
        // databases.list()가 반환하는 hostname을 그대로 사용합니다
        const client = createClient({
          url: `libsql://${db.hostname}`,
          authToken: tokenResult.jwt,
        });
 
        try {
          const drizzleDb = drizzle(client);
          await migrate(drizzleDb, { migrationsFolder: './drizzle' });
        } finally {
          // 성공·실패 여부와 관계없이 커넥션을 닫습니다
          client.close();
        }
 
        return db.name;
      })
    )
  );
 
  // Promise.allSettled를 쓴 이유: 한 테넌트 실패가 나머지를 멈추지 않아야 합니다
  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`✅ ${result.value} 완료`);
    } else {
      console.error(`❌ ${tenantDbs[index].name} 실패:`, result.reason);
    }
  });
}
 
migrateAllTenants().catch(console.error);