아키텍처 패턴 — 클린 아키텍처와 의존성 주입

src/
├── main/
│   ├── index.ts                # 진입점 (앱 초기화)
│   ├── modules/                # 기능별 모듈
│   │   ├── window/
│   │   │   ├── WindowManager.ts
│   │   │   └── WindowFactory.ts
│   │   ├── file/
│   │   │   ├── FileService.ts
│   │   │   └── FileHandlers.ts  # IPC 핸들러
│   │   └── update/
│   │       └── UpdateService.ts
│   ├── services/               # 인프라 서비스
│   │   ├── Database.ts
│   │   ├── Logger.ts
│   │   └── ConfigStore.ts
│   └── ipc/                    # IPC 라우터
│       └── registerHandlers.ts
├── preload/
│   └── index.ts
└── renderer/
    └── src/

// main/services/Database.ts
interface DatabasePort {
  query<T>(sql: string, params?: unknown[]): T[];
  run(sql: string, params?: unknown[]): { changes: number };
}

class SQLiteDatabase implements DatabasePort {
  private db: BetterSqlite3.Database;

  constructor(dbPath: string) {
    this.db = new Database(dbPath);
    this.db.pragma('journal_mode = WAL');
  }

  query<T>(sql: string, params: unknown[] = []): T[] {
    return this.db.prepare(sql).all(...params) as T[];
  }

  run(sql: string, params: unknown[] = []) {
    return this.db.prepare(sql).run(...params);
  }
}

// main/modules/file/FileService.ts
class FileService {
  constructor(
    private db: DatabasePort,
    private logger: Logger,
  ) {}

  async getRecentFiles(limit = 10) {
    this.logger.info('최근 파일 조회');
    return this.db.query(
      'SELECT * FROM recent_files ORDER BY opened_at DESC LIMIT ?',
      [limit]
    );
  }

  async openFile(filePath: string) {
    const content = await fs.promises.readFile(filePath, 'utf-8');
    this.db.run(
      'INSERT OR REPLACE INTO recent_files (path, opened_at) VALUES (?, ?)',
      [filePath, new Date().toISOString()]
    );
    this.logger.info(`파일 열기: ${filePath}`);
    return content;
  }
}

// main/modules/file/FileHandlers.ts
export function registerFileHandlers(fileService: FileService) {
  ipcMain.handle('file:open', async (_event, filePath: string) => {
    return fileService.openFile(filePath);
  });

  ipcMain.handle('file:recent', async () => {
    return fileService.getRecentFiles();
  });
}

// main/ipc/registerHandlers.ts
export function registerAllHandlers(container: Container) {
  registerFileHandlers(container.get('fileService'));
  registerNoteHandlers(container.get('noteService'));
  registerSettingsHandlers(container.get('configStore'));
}

// main/container.ts
class Container {
  private instances = new Map<string, unknown>();
  private factories = new Map<string, () => unknown>();

  register(name: string, factory: () => unknown) {
    this.factories.set(name, factory);
  }

  get<T>(name: string): T {
    if (!this.instances.has(name)) {
      const factory = this.factories.get(name);
      if (!factory) throw new Error(`서비스를 찾을 수 없음: ${name}`);
      this.instances.set(name, factory());
    }
    return this.instances.get(name) as T;
  }
}

// 초기화
const container = new Container();

container.register('logger', () => new Logger());
container.register('database', () => new SQLiteDatabase(dbPath));
container.register('configStore', () => new ConfigStore());
container.register('fileService', () =>
  new FileService(container.get('database'), container.get('logger'))
);
container.register('windowManager', () =>
  new WindowManager(container.get('configStore'))
);

// main/index.ts
import { app } from 'electron';
import { Container } from './container';
import { registerAllHandlers } from './ipc/registerHandlers';

async function bootstrap() {
  const container = createContainer();

  // IPC 핸들러 등록
  registerAllHandlers(container);

  // 윈도우 생성
  const windowManager = container.get<WindowManager>('windowManager');
  windowManager.createMainWindow();
}

app.whenReady().then(bootstrap);