비동기 이터레이터와 for-await-of

import * as fs from 'fs';
import * as readline from 'readline';

async function* readLinesFromFile(filePath: string): AsyncGenerator<string> {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity,
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processLargeFile(filePath: string): Promise<void> {
  console.log(`Processing file: ${filePath}`);
  try {
    let lineNumber = 1;
    for await (const line of readLinesFromFile(filePath)) {
      console.log(`Line ${lineNumber++}: ${line}`);
      // await new Promise(resolve => setTimeout(resolve, 10)); // 각 라인 처리의 비동기 시뮬레이션
    }
    console.log("Finished processing file.");
  } catch (error) {
    console.error("Error processing file:", error);
  }
}

// 예시 사용: 'my_large_file.txt' 라는 파일이 있다고 가정
// Node.js 환경에서 실행 가능
// require('fs').writeFileSync('my_large_file.txt', 'Line 1\nLine 2\nLine 3\n');
// processLargeFile('my_large_file.txt');

// 가상의 웹소켓 클라이언트 (실제 구현은 ws 라이브러리 등 사용)
class MockWebSocket {
  private messages: string[] = ['Hello', 'World', 'Async', 'Iterator', 'Done!'];
  private index = 0;

  async *[Symbol.asyncIterator](): AsyncGenerator<string> {
    while (this.index < this.messages.length) {
      await new Promise(resolve => setTimeout(resolve, 300)); // 메시지 수신 대기 시뮬레이션
      const message = this.messages[this.index++];
      console.log(`[WebSocket] Sending: ${message}`);
      yield message;
    }
  }
}

async function processWebSocketMessages(): Promise<void> {
  console.log("Connecting to WebSocket...");
  const ws = new MockWebSocket(); // 실제로는 new WebSocket(...)
  for await (const msg of ws) {
    console.log(`[App] Received: ${msg}`);
    if (msg === 'Done!') {
      break; // 특정 메시지 수신 시 종료
    }
  }
  console.log("WebSocket message processing finished.");
}

processWebSocketMessages();

// 가상의 데이터베이스 커서
interface DbRecord {
  id: number;
  name: string;
}

class MockDbCursor {
  private data: DbRecord[] = [
    { id: 1, name: 'Item A' },
    { id: 2, name: 'Item B' },
    { id: 3, name: 'Item C' },
    { id: 4, name: 'Item D' },
  ];
  private currentIndex = 0;
  private pageSize = 2; // 페이지당 가져올 레코드 수

  async *[Symbol.asyncIterator](): AsyncGenerator<DbRecord[]> {
    while (this.currentIndex < this.data.length) {
      const page = this.data.slice(this.currentIndex, this.currentIndex + this.pageSize);
      this.currentIndex += this.pageSize;
      await new Promise(resolve => setTimeout(resolve, 700)); // DB 쿼리 지연 시뮬레이션
      console.log(`[DB Cursor] Yielding page with ${page.length} records.`);
      yield page; // 레코드 묶음을 페이지 단위로 yield
    }
  }
}

async function processDatabaseRecords(): Promise<void> {
  console.log("Fetching database records...");
  const cursor = new MockDbCursor();

  for await (const page of cursor) {
    console.log(`[App] Processing new page of records (${page.length} items):`);
    for (const record of page) {
      console.log(`  - Record: ${record.id}, ${record.name}`);
    }
    await new Promise(resolve => setTimeout(resolve, 300)); // 각 페이지 처리의 비동기 시뮬레이션
  }
  console.log("Finished processing all database records.");
}

processDatabaseRecords();