using 키워드와 Disposable — 리소스 자동 해제 패턴

// ❌ 파일 핸들이나 DB 연결을 수동으로 닫아야 함
const handle = openFile('data.txt');
try {
  const data = handle.read();
  processData(data);
} finally {
  handle.close(); // 항상 닫아야 함 — 잊기 쉬움
}

// ✅ using 키워드 — 스코프 끝에서 자동 해제
{
  using handle = openFile('data.txt');
  const data = handle.read();
  processData(data);
} // ← 여기서 자동으로 handle[Symbol.dispose]() 호출

// 동기 해제
interface Disposable {
  [Symbol.dispose](): void;
}

// 비동기 해제
interface AsyncDisposable {
  [Symbol.asyncDispose](): Promise<void>;
}

class FileHandle implements Disposable {
  private closed = false;

  constructor(private path: string) {
    console.log(`파일 열기: ${path}`);
  }

  read(): string {
    if (this.closed) throw new Error('이미 닫힌 파일');
    return '파일 내용';
  }

  [Symbol.dispose](): void {
    if (!this.closed) {
      console.log(`파일 닫기: ${this.path}`);
      this.closed = true;
    }
  }
}

// 사용
function processFile() {
  using file = new FileHandle('data.txt');
  // 파일 열기: data.txt
  const data = file.read();
  console.log(data);
  // 함수 끝에서 자동: 파일 닫기: data.txt
}

class DatabaseConnection implements AsyncDisposable {
  private connected = true;

  static async connect(url: string): Promise<DatabaseConnection> {
    console.log(`DB 연결: ${url}`);
    return new DatabaseConnection();
  }

  async query(sql: string): Promise<any[]> {
    if (!this.connected) throw new Error('연결 끊김');
    return []; // 쿼리 결과
  }

  async [Symbol.asyncDispose](): Promise<void> {
    if (this.connected) {
      console.log('DB 연결 해제');
      this.connected = false;
    }
  }
}

// 사용
async function fetchData() {
  await using db = await DatabaseConnection.connect('postgres://localhost:5432');
  const users = await db.query('SELECT * FROM users');
  console.log(users);
} // ← 자동으로 db[Symbol.asyncDispose]() 호출

function setupServer() {
  using stack = new DisposableStack();

  // 여러 리소스를 스택에 추가
  const db = stack.use(new DatabasePool());
  const cache = stack.use(new CacheConnection());
  const logger = stack.use(new FileLogger());

  // 추가 정리 로직도 등록 가능
  stack.defer(() => {
    console.log('서버 종료 정리 완료');
  });

  return { db, cache, logger };
} // ← 스택에 등록된 모든 리소스가 역순으로 해제됨

class TempFile implements Disposable {
  public path: string;

  constructor(prefix: string) {
    this.path = `/tmp/${prefix}_${Date.now()}`;
    // 임시 파일 생성
    writeFileSync(this.path, '');
  }

  [Symbol.dispose](): void {
    // 자동으로 임시 파일 삭제
    if (existsSync(this.path)) {
      unlinkSync(this.path);
    }
  }
}

function processWithTempFile() {
  using temp = new TempFile('upload');
  writeFileSync(temp.path, '임시 데이터');
  // 처리...
} // ← temp 파일 자동 삭제

class Lock implements Disposable {
  private released = false;

  constructor(private resource: string) {
    console.log(`락 획득: ${resource}`);
  }

  [Symbol.dispose](): void {
    if (!this.released) {
      console.log(`락 해제: ${this.resource}`);
      this.released = true;
    }
  }
}

function criticalSection() {
  using lock = new Lock('shared-resource');
  // 임계 구역 코드
  // ...
} // ← 자동으로 락 해제 (예외가 발생해도)

class Interval implements Disposable {
  private id: ReturnType<typeof setInterval>;

  constructor(callback: () => void, ms: number) {
    this.id = setInterval(callback, ms);
  }

  [Symbol.dispose](): void {
    clearInterval(this.id);
  }
}

function monitorHealth() {
  using healthCheck = new Interval(() => {
    console.log('헬스 체크...');
  }, 5000);

  // 다른 작업...
} // ← 자동으로 인터벌 정리

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022", "ESNext.Disposable"]
  }
}