TypeScript `using`과 `Symbol.asyncDispose`로 DB 커넥션 누수를 언어 레벨에서 차단하기

// 기존 방식 — finally를 빠뜨리면 커넥션이 풀로 돌아오지 않음
const client = await pool.connect();
try {
  await client.query('BEGIN');
  // ... 비즈니스 로직 ...
  await client.query('COMMIT');
} finally {
  client.release();
}
 
// Explicit Resource Management 방식
await using client = await acquireClient(pool);
await client.query('BEGIN');
// ... 비즈니스 로직 ...
await client.query('COMMIT');
// 블록 종료 시 client[Symbol.asyncDispose]() 자동 호출
// 에러가 발생해도 반드시 실행됨

flowchart TD
    A[함수 진입] --> B[await using res 선언]
    B --> C[비즈니스 로직 실행]
    C --> D{에러 발생?}
    D -->|아니오| E[함수 정상 종료]
    D -->|예| F[에러 캐치]
    E --> G[Symbol.asyncDispose 자동 호출]
    F --> G
    G --> H[리소스 정리 완료]
    H --> I{에러 존재?}
    I -->|예| J[에러 전파]
    I -->|아니오| K[정상 반환]

// 동기 Disposable 예시
class ManagedFileHandle implements Disposable {
  constructor(private fd: number) {}
 
  [Symbol.dispose]() {
    fs.closeSync(this.fd);
  }
}
 
// 비동기 AsyncDisposable 예시
class ManagedDbClient implements AsyncDisposable {
  constructor(private client: PoolClient) {}
 
  async [Symbol.asyncDispose]() {
    this.client.release();
  }
}

{
  "compilerOptions": {
    "target": "es2022",
    "lib": ["es2022", "esnext.disposable"],
    "module": "NodeNext"
  }
}

flowchart LR
    A[TypeScript 소스] --> B{tsc target 버전}
    B -->|es2022 이상| C[using 구문 그대로 출력]
    B -->|es2021 이하| D[try/finally로 다운트랜스파일]
    C --> E{런타임}
    E -->|Node.js 22 이상| F[네이티브 파싱]
    E -->|Bun v1.3.12 이상| F
    E -->|Deno 1.38 이상| F
    F --> G[Symbol.asyncDispose 실행]
    D --> H[구형 런타임에서도 동작]

async function importData(srcUrl: string) {
  await using stack = new AsyncDisposableStack();
 
  const conn = stack.use(await acquireDbConnection());     // AsyncDisposable 구현체 등록
  const file = stack.use(await openRemoteStream(srcUrl));  // 동일하게 등록
  stack.defer(async () => await sendAuditLog('import.done')); // 임의 클린업 함수
  stack.adopt(rawHandle, (h) => h.close());               // 비-Disposable에 dispose 부여
 
  for await (const chunk of file.readable) {
    await conn.query(/* ... */);
  }
  // 스코프 종료 시 sendAuditLog → file → conn 순서로 자동 정리
}

import { Pool, PoolClient } from 'pg';
 
class ManagedClient implements AsyncDisposable {
  constructor(private client: PoolClient) {}
 
  async query(sql: string, params?: unknown[]) {
    return this.client.query(sql, params);
  }
 
  async [Symbol.asyncDispose]() {
    this.client.release();
  }
}
 
async function acquireClient(pool: Pool): Promise<ManagedClient> {
  const client = await pool.connect();
  return new ManagedClient(client);
}
 
// 사용 측 — try/finally 없이 누수 방지
async function getUser(pool: Pool, id: string) {
  await using client = await acquireClient(pool);
  const { rows } = await client.query('SELECT * FROM users WHERE id = $1', [id]);
  return rows[0];
} // 여기서 client[Symbol.asyncDispose]() → client.release() 자동 호출

import { MongoClient, ClientSession } from 'mongodb';
 
class ManagedTransaction implements AsyncDisposable {
  private committed = false;
 
  constructor(public session: ClientSession) {}
 
  commit() {
    this.committed = true;
  }
 
  async [Symbol.asyncDispose]() {
    if (!this.committed) {
      await this.session.abortTransaction();
    }
    await this.session.endSession();
  }
}
 
function beginTransaction(client: MongoClient): ManagedTransaction {
  const session = client.startSession();
  session.startTransaction();
  return new ManagedTransaction(session);
}
 
async function transfer(client: MongoClient, from: string, to: string, amount: number) {
  const db = client.db();
  await using tx = beginTransaction(client);
 
  await db.collection('accounts').updateOne(
    { _id: from },
    { $inc: { balance: -amount } },
    { session: tx.session }
  );
  await db.collection('accounts').updateOne(
    { _id: to },
    { $inc: { balance: amount } },
    { session: tx.session }
  );
 
  await tx.session.commitTransaction();
  tx.commit(); // 이 줄 전에 에러 발생하면 → dispose에서 자동 롤백
}

flowchart TD
    A[transfer 함수 진입] --> B[beginTransaction으로 세션 시작]
    B --> C[계좌 잔액 업데이트]
    C --> D{에러 발생?}
    D -->|예| E[commit 미호출]
    D -->|아니오| F[commitTransaction 호출]
    F --> G[tx.commit 호출로 플래그 활성화]
    G --> H[스코프 종료]
    E --> H
    H --> I[Symbol.asyncDispose 호출]
    I --> J{committed?}
    J -->|아니오| K[abortTransaction 자동 롤백]
    J -->|예| L[세션 종료만]
    K --> M[endSession]
    L --> M

const sql = new Bun.SQL(process.env.DATABASE_URL!);
 
async function runInTransaction() {
  await using reserved = await sql.reserve(); // ReservedSQL은 AsyncDisposable 구현체
  await reserved`BEGIN`;
  await reserved`INSERT INTO logs VALUES (${Date.now()})`;
  await reserved`COMMIT`;
} // 스코프 종료 시 커넥션 자동 반환

async function importData(srcUrl: string) {
  await using stack = new AsyncDisposableStack();
 
  const conn = stack.use(await acquireDbConnection());
  const file = stack.use(await openRemoteStream(srcUrl));
  stack.defer(async () => await sendAuditLog('import.done'));
 
  // 에러 발생 여부와 무관하게 LIFO 순서로 정리
  // sendAuditLog → file → conn 순서
  for await (const chunk of file.readable) {
    await conn.query(/* ... */);
  }
}

try {
  await using client = await acquireClient(pool);
  throw new Error('비즈니스 로직 에러');
  // dispose에서도 에러가 발생하는 상황 가정
} catch (err) {
  if (err instanceof SuppressedError) {
    console.error('dispose 에러:', err.error);      // dispose 중 발생한 에러 (억압한 쪽)
    console.error('본문 에러:', err.suppressed);    // 본문에서 먼저 발생한 에러 (억압당한 쪽)
  } else {
    console.error(err);
  }
}