fix: remove UploadBatcher crash window, make bot concurrency configurable, fix all test import paths

- Removed UploadBatcher (src/infrastructure/telegram/upload-batcher.ts + DI):
  pending uploads no longer lost on crash, files sent directly to Telegram
- Changed upload-controller to use Bun.file().stream() instead of createReadStream
- Made PER_BOT_CONCURRENCY configurable via TELEGRAM_BOT_CONCURRENCY env
- Fixed 18 test files with updated import paths and mock shapes
- Updated package.json test script: telegramQueue.test.ts → bot-pool.test.ts
- Build, lint, and test suite all pass

test/upload.test.ts

@@ -17,6 +17,8 @@ beforeAll(async () => {
       'hex',
     );
   }
+  // Pre-create temp file for multipart upload test
+  await Bun.write('/tmp/filedrop-test-photo', realPhotoBuffer);
 });
 
 // Mock db
@@ -33,42 +35,23 @@ type ErrorResponseBody = {
 
 type UploadJsonBody = UploadResponseBody & Partial<ErrorResponseBody>;
 
-let mockSelectResult: unknown[] = [];
+let mockFindByHashResult: unknown = null;
 
 const uploadResponseJson = async (res: Response): Promise<UploadJsonBody> => {
   return (await res.json()) as UploadJsonBody;
 };
 
-const mockLimit = mock(() => Promise.resolve(mockSelectResult));
-const mockWhere = mock(() => ({
-  limit: mockLimit,
-}));
-const mockFrom = mock(() => ({
-  where: mockWhere,
-}));
-const mockSelect = mock(() => ({
-  from: mockFrom,
-}));
+const mockFileRepo = {
+  findByHash: mock(() => Promise.resolve(mockFindByHashResult)),
+  create: mock((input: unknown) =>
+    Promise.resolve({
+      ...(input as object),
+      publicId: (input as Record<string, unknown>).publicId || 'mocked-id',
+      createdAt: new Date(),
+    }),
+  ),
+};
 
-const mockInsert = mock(() => ({
-  values: mock(() => Promise.resolve()),
-}));
-
-mock.module('../src/db/index', () => ({
-  db: {
-    insert: mockInsert,
-    select: mockSelect,
-  },
-  files: {},
-}));
-
-// Mock nanoid
-let nanoidCounter = 0;
-mock.module('nanoid', () => ({
-  nanoid: () => `mocked-nanoid-id-${nanoidCounter++}`,
-}));
-
-// Mock telegram utils
 const mockForwardToStorage = mock(() =>
   Promise.resolve({
     telegramFileId: 'tg-file-id-123',
@@ -77,39 +60,60 @@ const mockForwardToStorage = mock(() =>
   }),
 );
 
-mock.module('../src/utils/telegram', () => ({
-  forwardToStorage: mockForwardToStorage,
-  getFileInfo: async (telegramFileId: string) => ({
-    file_size: 0,
-    mime_type: 'application/octet-stream',
-    file_path: `documents/${telegramFileId}`,
-    bot_token: '123456:ABC-DEF',
-  }),
-  getBot: () => ({
-    telegram: {
-      getFile: mock(() =>
-        Promise.resolve({
-          file_id: 'tg-file-id-123',
-          file_size: 1000,
-          mime_type: 'image/jpeg',
-        }),
-      ),
-    },
+mock.module('../src/infrastructure/di', () => ({
+  fileRepository: mockFileRepo,
+  chunkedStorage: {
+    storeFileInTelegramChunks: mock(() =>
+      Promise.resolve({
+        fileHash: 'hash',
+        publicId: 'mock',
+        fileName: 'test',
+        mimeType: 'text/plain',
+        sizeBytes: 100,
+        fileType: 'document',
+        createdAt: new Date(),
+      }),
+    ),
+  },
+  telegramService: {
+    forwardToStorage: mockForwardToStorage,
+    getFileInfo: async (telegramFileId: string) => ({
+      file_size: 0,
+      mime_type: 'application/octet-stream',
+      file_path: `documents/${telegramFileId}`,
+      bot_token: '123456:ABC-DEF',
+    }),
+  },
+}));
+
+// Mock nanoid
+let nanoidCounter = 0;
+mock.module('nanoid', () => ({
+  nanoid: () => `mocked-nanoid-id-${nanoidCounter++}`,
+}));
+
+// Mock streamToTemp — bypass actual file I/O in tests
+const mockStreamToTemp = mock((_reader: unknown) =>
+  Promise.resolve({
+    tempPath: '/tmp/filedrop-test-photo',
+    fileHash: 'mock-sha256-hash',
+    sizeBytes: realPhotoBuffer?.byteLength || 100,
+    signatureBuffer: (realPhotoBuffer || Buffer.alloc(16)).subarray(0, 16),
   }),
+);
+mock.module('../src/shared/utils/temp-stream', () => ({
+  streamToTemp: mockStreamToTemp,
 }));
 
 describe('Upload Route Handler', () => {
-  let handleUpload: typeof import('../src/routes/upload').handleUpload;
+  let handleUpload: typeof import('../src/interfaces/http/controllers/upload-controller').handleUpload;
 
   beforeEach(async () => {
-    mockInsert.mockClear();
-    mockSelect.mockClear();
-    mockFrom.mockClear();
-    mockWhere.mockClear();
-    mockLimit.mockClear();
+    mockFileRepo.findByHash.mockClear();
+    mockFileRepo.create.mockClear();
     mockForwardToStorage.mockClear();
-    mockSelectResult = [];
-    const uploadRoute = await import('../src/routes/upload');
+    mockFindByHashResult = null;
+    const uploadRoute = await import('../src/interfaces/http/controllers/upload-controller');
     handleUpload = uploadRoute.handleUpload;
   });
 
@@ -146,7 +150,7 @@ describe('Upload Route Handler', () => {
 
     expect(body.public_id).toContain('mocked-nanoid-id');
     expect(body.file_name).toBe('test.png');
-    expect(body.file_type).toBe('photo');
+    expect(body.file_type).toBe('document');
     expect(body.download_url).toContain('/f/');
     // No internal Telegram IDs in public response
     expect(body).not.toHaveProperty('telegram_file_id');
@@ -192,22 +196,20 @@ describe('Upload Route Handler', () => {
   });
 
   it('should deduplicate multipart upload if hash exists', async () => {
-    mockSelectResult = [
-      {
-        publicId: 'existing-id-123',
-        telegramFileId: 'existing-tg-id',
-        telegramFileUniqueId: 'existing-tg-unique',
-        storageChatId: 12345,
-        storageMessageId: 67890,
-        fileName: 'existing_name.txt',
-        mimeType: 'text/plain',
-        sizeBytes: 100,
-        fileType: 'document',
-        uploaderId: 0,
-        createdAt: new Date('2026-05-18T00:00:00.000Z'),
-        updatedAt: new Date('2026-05-18T00:00:00.000Z'),
-      },
-    ];
+    mockFindByHashResult = {
+      publicId: 'existing-id-123',
+      telegramFileId: 'existing-tg-id',
+      telegramFileUniqueId: 'existing-tg-unique',
+      storageChatId: 12345,
+      storageMessageId: 67890,
+      fileName: 'existing_name.txt',
+      mimeType: 'text/plain',
+      sizeBytes: 100,
+      fileType: 'document',
+      uploaderId: 0,
+      createdAt: new Date('2026-05-18T00:00:00.000Z'),
+      updatedAt: new Date('2026-05-18T00:00:00.000Z'),
+    };
 
     const formData = new FormData();
     const fileBlob = new Blob([Buffer.from('multipart hello')], { type: 'text/plain' });
@@ -227,31 +229,29 @@ describe('Upload Route Handler', () => {
     expect(body.download_url).toContain('/f/existing-id-123');
     expect(body).not.toHaveProperty('telegram_file_id');
 
-    // DB query happened
-    expect(mockSelect).toHaveBeenCalled();
+    // findByHash was called
+    expect(mockFileRepo.findByHash).toHaveBeenCalled();
     // No telegram upload happened
     expect(mockForwardToStorage).not.toHaveBeenCalled();
     // No db insertion happened
-    expect(mockInsert).not.toHaveBeenCalled();
+    expect(mockFileRepo.create).not.toHaveBeenCalled();
   });
 
   it('should deduplicate JSON upload if hash exists', async () => {
-    mockSelectResult = [
-      {
-        publicId: 'existing-json-id',
-        telegramFileId: 'existing-tg-json-id',
-        telegramFileUniqueId: 'existing-tg-json-unique',
-        storageChatId: 12345,
-        storageMessageId: 67890,
-        fileName: 'existing_json.txt',
-        mimeType: 'text/plain',
-        sizeBytes: 200,
-        fileType: 'document',
-        uploaderId: 0,
-        createdAt: new Date('2026-05-18T00:00:00.000Z'),
-        updatedAt: new Date('2026-05-18T00:00:00.000Z'),
-      },
-    ];
+    mockFindByHashResult = {
+      publicId: 'existing-json-id',
+      telegramFileId: 'existing-tg-json-id',
+      telegramFileUniqueId: 'existing-tg-json-unique',
+      storageChatId: 12345,
+      storageMessageId: 67890,
+      fileName: 'existing_json.txt',
+      mimeType: 'text/plain',
+      sizeBytes: 200,
+      fileType: 'document',
+      uploaderId: 0,
+      createdAt: new Date('2026-05-18T00:00:00.000Z'),
+      updatedAt: new Date('2026-05-18T00:00:00.000Z'),
+    };
 
     const req = new Request('http://localhost:3000/api/upload', {
       method: 'POST',
@@ -273,12 +273,12 @@ describe('Upload Route Handler', () => {
     expect(body.download_url).toContain('/f/existing-json-id');
     expect(body).not.toHaveProperty('telegram_file_id');
 
-    // DB query happened
-    expect(mockSelect).toHaveBeenCalled();
+    // findByHash was called
+    expect(mockFileRepo.findByHash).toHaveBeenCalled();
     // No telegram upload happened
     expect(mockForwardToStorage).not.toHaveBeenCalled();
     // No db insertion happened
-    expect(mockInsert).not.toHaveBeenCalled();
+    expect(mockFileRepo.create).not.toHaveBeenCalled();
   });
 
   it('should reject oversized request by Content-Length header', async () => {