@kiyasov/platform-hono 1.6.1 → 2.0.1

package/test/multipart-upload.test.ts

@@ -0,0 +1,354 @@
+import { describe, expect, test } from 'bun:test';
+
+import { THonoRequest } from '../src/multer/multipart/request';
+import { MemoryStorage } from '../src/multer/storage/memory-storage';
+import { StorageFile } from '../src/multer/storage/storage';
+
+describe('Multipart Upload Handlers', () => {
+  describe('FileHandler', () => {
+    test('should process single file upload', async () => {
+      const { FileHandler } =
+        await import('../src/multer/multipart/handlers/base-handler');
+      const storage = new MemoryStorage();
+      const options = {
+        storage,
+      };
+
+      // Create mock file
+      const file = new File(['test content'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockReq = {
+        body: {
+          file,
+          otherField: 'value',
+        },
+        header: (name: string) =>
+          name === 'content-type' ? 'multipart/form-data' : null,
+      } as unknown as THonoRequest;
+
+      const handler = new FileHandler(mockReq, options);
+      let uploadedFile: StorageFile | undefined;
+
+      await handler.process(async (fieldName, part) => {
+        if (part instanceof File) {
+          const storageFile = await handler.handleSingleFile(fieldName, part);
+          if (storageFile) {
+            uploadedFile = storageFile;
+            handler.addFile(fieldName, storageFile);
+          }
+        }
+      });
+
+      expect(uploadedFile).toBeDefined();
+      expect(uploadedFile?.fieldName).toBe('file');
+      expect(uploadedFile?.originalFilename).toBe('test.txt');
+      expect(uploadedFile?.mimetype).toContain('text/plain');
+      expect(uploadedFile?.size).toBe(12); // 'test content' length
+
+      // Check body
+      const body = handler.getBody();
+      expect(body.otherField).toBe('value');
+      // Note: file is removed from body during processing
+
+      // Cleanup
+      await handler.cleanup();
+    });
+
+    test('should validate field name', async () => {
+      const { FileHandler } =
+        await import('../src/multer/multipart/handlers/base-handler');
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+      const mockReq = {
+        body: { wrongField: file },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const handler = new FileHandler(mockReq, options);
+
+      let errorThrown = false;
+      try {
+        await handler.process(async (fieldName) => {
+          handler.validateFieldName(fieldName, 'correctField');
+        });
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          "doesn't accept file",
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+
+    test('should validate max count', async () => {
+      const { FileHandler } =
+        await import('../src/multer/multipart/handlers/base-handler');
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+      const mockReq = {
+        body: { files: [file, file] },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const handler = new FileHandler(mockReq, options);
+      let fileCount = 0;
+      const maxCount = 1;
+
+      let errorThrown = false;
+      try {
+        await handler.process(async (fieldName) => {
+          handler.validateMaxCount(fieldName, fileCount, maxCount);
+          fileCount++;
+        });
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          'accepts max 1 files',
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+
+    test('should prevent double cleanup', async () => {
+      const { FileHandler } =
+        await import('../src/multer/multipart/handlers/base-handler');
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+      const mockReq = {
+        body: { file },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const handler = new FileHandler(mockReq, options);
+
+      await handler.process(async (fieldName, part) => {
+        const storageFile = await handler.handleSingleFile(fieldName, part);
+        if (storageFile) {
+          handler.addFile(fieldName, storageFile);
+        }
+      });
+
+      const removeFn = handler.createRemoveFunction();
+
+      // First cleanup
+      await removeFn();
+
+      // Second cleanup should be no-op
+      await removeFn();
+
+      // Files array should be cleared
+      expect(handler.getFiles()).toHaveLength(0);
+    });
+
+    test('should handle filtered file', async () => {
+      const { FileHandler } =
+        await import('../src/multer/multipart/handlers/base-handler');
+      const storage = new MemoryStorage();
+      const options = {
+        storage,
+        filter: () => {
+          return false; // Reject file
+        },
+      };
+
+      const file = new File(['test'], 'test.exe', {
+        type: 'application/x-executable',
+      });
+      const mockReq = {
+        body: { file },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const handler = new FileHandler(mockReq, options);
+
+      await handler.process(async (fieldName, part) => {
+        await handler.handleSingleFile(fieldName, part);
+      });
+
+      // File should not be in the list (filtered out)
+      expect(handler.getFiles()).toHaveLength(0);
+    });
+  });
+
+  describe('handleMultipartSingleFile', () => {
+    test('should handle single file upload successfully', async () => {
+      const { handleMultipartSingleFile } =
+        await import('../src/multer/multipart/handlers/single-file');
+
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file = new File(['content'], 'photo.jpg', { type: 'image/jpeg' });
+      const mockReq = {
+        body: { photo: file, name: 'John' },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const result = await handleMultipartSingleFile(mockReq, 'photo', options);
+
+      expect(result.file).toBeDefined();
+      expect(result.file?.fieldName).toBe('photo');
+      expect(result.file?.originalFilename).toBe('photo.jpg');
+      expect(result.body.name).toBe('John');
+      // Note: The file is removed from body during processing, so this is expected
+    });
+  });
+
+  describe('handleMultipartMultipleFiles', () => {
+    test('should handle multiple files upload', async () => {
+      const { handleMultipartMultipleFiles } =
+        await import('../src/multer/multipart/handlers/multiple-files');
+
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file1 = new File(['content1'], 'file1.txt', { type: 'text/plain' });
+      const file2 = new File(['content2'], 'file2.txt', { type: 'text/plain' });
+      const mockReq = {
+        body: { files: [file1, file2] },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const result = await handleMultipartMultipleFiles(
+        mockReq,
+        'files',
+        5,
+        options,
+      );
+
+      expect(result.files).toHaveLength(2);
+      expect(result.files[0].fieldName).toBe('files');
+      expect(result.files[1].fieldName).toBe('files');
+    });
+
+    test('should enforce max count limit', async () => {
+      const { handleMultipartMultipleFiles } =
+        await import('../src/multer/multipart/handlers/multiple-files');
+
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file1 = new File(['content1'], 'file1.txt', {
+        type: 'text/plain',
+      });
+      const file2 = new File(['content2'], 'file2.txt', {
+        type: 'text/plain',
+      });
+      const file3 = new File(['content3'], 'file3.txt', {
+        type: 'text/plain',
+      });
+
+      const mockReq = {
+        body: { files: [file1, file2, file3] },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      let errorThrown = false;
+      try {
+        await handleMultipartMultipleFiles(mockReq, 'files', 2, options);
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          'accepts max 2 files',
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+  });
+
+  describe('handleMultipartFileFields', () => {
+    test('should handle multiple file fields', async () => {
+      const { handleMultipartFileFields, uploadFieldsToMap } =
+        await import('../src/multer/multipart/handlers/file-fields');
+
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const avatar = new File(['avatar'], 'avatar.jpg', { type: 'image/jpeg' });
+      const document = new File(['doc'], 'doc.pdf', {
+        type: 'application/pdf',
+      });
+      const mockReq = {
+        body: { avatar, document },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const fieldsMap = uploadFieldsToMap([
+        { name: 'avatar', maxCount: 1 },
+        { name: 'document', maxCount: 1 },
+      ]);
+
+      const result = await handleMultipartFileFields(
+        mockReq,
+        fieldsMap,
+        options,
+      );
+
+      expect(result.files.avatar).toHaveLength(1);
+      expect(result.files.document).toHaveLength(1);
+      expect(result.files.avatar[0].originalFilename).toBe('avatar.jpg');
+      expect(result.files.document[0].originalFilename).toBe('doc.pdf');
+    });
+
+    test('should reject unknown file fields', async () => {
+      const { handleMultipartFileFields, uploadFieldsToMap } =
+        await import('../src/multer/multipart/handlers/file-fields');
+
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file = new File(['content'], 'unknown.txt', { type: 'text/plain' });
+      const mockReq = {
+        body: { unknown: file },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const fieldsMap = uploadFieldsToMap([{ name: 'allowed', maxCount: 1 }]);
+
+      let errorThrown = false;
+      try {
+        await handleMultipartFileFields(mockReq, fieldsMap, options);
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          "doesn't accept files",
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+  });
+
+  describe('handleMultipartAnyFiles', () => {
+    test('should accept any files', async () => {
+      const { handleMultipartAnyFiles } =
+        await import('../src/multer/multipart/handlers/any-files');
+
+      const storage = new MemoryStorage();
+      const options = { storage };
+
+      const file1 = new File(['content1'], 'file1.txt', { type: 'text/plain' });
+      const file2 = new File(['content2'], 'file2.jpg', { type: 'image/jpeg' });
+      const mockReq = {
+        body: { file1, file2, name: 'test' },
+        header: () => 'multipart/form-data',
+      } as unknown as THonoRequest;
+
+      const result = await handleMultipartAnyFiles(mockReq, options);
+
+      expect(result.files).toHaveLength(2);
+      expect(result.body.name).toBe('test');
+    });
+  });
+});

package/test/smoke.test.ts

@@ -0,0 +1,227 @@
+import { describe, expect, test } from 'bun:test';
+
+import { THonoRequest } from '../src/multer/multipart/request';
+
+/**
+ * Simple smoke tests to verify core functionality works
+ */
+describe('File Upload Smoke Tests', () => {
+  test('MemoryStorage should store and retrieve file', async () => {
+    const { MemoryStorage } =
+      await import('../src/multer/storage/memory-storage');
+    const storage = new MemoryStorage();
+
+    const file = new File(['test content'], 'test.txt', {
+      type: 'text/plain',
+    });
+    const mockReq = {
+      header: () => 'multipart/form-data',
+    } as unknown as THonoRequest;
+
+    const storedFile = await storage.handleFile(file, mockReq, 'file');
+
+    expect(storedFile).toBeDefined();
+    expect(storedFile.fieldName).toBe('file');
+    expect(storedFile.originalFilename).toBe('test.txt');
+    expect(storedFile.size).toBe(12);
+    expect(storedFile.buffer).toBeInstanceOf(Buffer);
+    expect(storedFile.buffer.byteLength).toBe(12);
+
+    // Cleanup
+    await storage.removeFile(storedFile);
+  });
+
+  test('FileHandler should process file without errors', async () => {
+    const { FileHandler } =
+      await import('../src/multer/multipart/handlers/base-handler');
+    const { MemoryStorage } =
+      await import('../src/multer/storage/memory-storage');
+
+    const storage = new MemoryStorage();
+    const options = { storage };
+
+    const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+    const mockReq = {
+      body: { file },
+      header: () => 'multipart/form-data',
+    } as unknown as THonoRequest;
+
+    const handler = new FileHandler(mockReq, options);
+
+    let processed = false;
+    await handler.process(async (fieldName, part) => {
+      if (part instanceof File) {
+        const storageFile = await handler.handleSingleFile(fieldName, part);
+        if (storageFile) {
+          processed = true;
+          expect(storageFile.fieldName).toBe('file');
+          expect(storageFile.originalFilename).toBe('test.txt');
+        }
+      }
+    });
+
+    expect(processed).toBe(true);
+
+    // Cleanup
+    await handler.cleanup();
+  });
+
+  test('createRemoveFunction should prevent multiple calls', async () => {
+    const { FileHandler } =
+      await import('../src/multer/multipart/handlers/base-handler');
+    const { MemoryStorage } =
+      await import('../src/multer/storage/memory-storage');
+
+    const storage = new MemoryStorage();
+    const options = { storage };
+
+    const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+    const mockReq = {
+      body: { file },
+      header: () => 'multipart/form-data',
+    } as unknown as THonoRequest;
+
+    const handler = new FileHandler(mockReq, options);
+
+    await handler.process(async (fieldName, part) => {
+      const storageFile = await handler.handleSingleFile(fieldName, part);
+      if (storageFile) {
+        handler.addFile(fieldName, storageFile);
+      }
+    });
+
+    const removeFn = handler.createRemoveFunction();
+
+    // First call should work
+    await removeFn();
+
+    // Verify files are cleared
+    expect(handler.getFiles()).toHaveLength(0);
+
+    // Second call should be no-op (should not throw)
+    await removeFn();
+
+    // Should still be empty
+    expect(handler.getFiles()).toHaveLength(0);
+  });
+
+  test('cleanup should happen automatically on error', async () => {
+    const { FileHandler } =
+      await import('../src/multer/multipart/handlers/base-handler');
+    const { MemoryStorage } =
+      await import('../src/multer/storage/memory-storage');
+
+    const storage = new MemoryStorage();
+    const options = { storage };
+
+    const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+    const mockReq = {
+      body: { file },
+      header: () => 'multipart/form-data',
+    } as unknown as THonoRequest;
+
+    const handler = new FileHandler(mockReq, options);
+
+    let errorThrown = false;
+    try {
+      await handler.process(async (fieldName, part) => {
+        const storageFile = await handler.handleSingleFile(fieldName, part);
+        if (storageFile) {
+          handler.addFile(fieldName, storageFile);
+        }
+        // Simulate error
+        throw new Error('Test error');
+      });
+    } catch (err) {
+      errorThrown = true;
+      expect(err instanceof Error && err.message).toBe('Test error');
+    }
+
+    expect(errorThrown).toBe(true);
+
+    // Cleanup should have happened automatically
+    expect(handler.getFiles()).toHaveLength(0);
+  });
+
+  test('getParts should validate file size limits', async () => {
+    const { getParts } = await import('../src/multer/multipart/request');
+
+    const largeFile = new File(['x'.repeat(1000)], 'large.txt', {
+      type: 'text/plain',
+    });
+    const smallFile = new File(['small'], 'small.txt', { type: 'text/plain' });
+
+    const mockReq = {
+      body: {
+        largeFile,
+        smallFile,
+      },
+      header: () => 'multipart/form-data',
+    } as unknown as THonoRequest;
+
+    // Should throw error for large file
+    let errorThrown = false;
+    try {
+      getParts(mockReq, { limits: { fileSize: 100 } });
+    } catch (err) {
+      errorThrown = true;
+      expect(err instanceof Error && err.message).toContain('too large');
+    }
+
+    expect(errorThrown).toBe(true);
+  });
+
+  test('uploadFieldsToMap should create proper map', async () => {
+    const { uploadFieldsToMap } =
+      await import('../src/multer/multipart/handlers/file-fields');
+
+    const fields = uploadFieldsToMap([
+      { name: 'avatar', maxCount: 1 },
+      { name: 'photos', maxCount: 5 },
+      { name: 'documents' },
+    ]);
+
+    expect(fields.get('avatar')).toEqual({ maxCount: 1 });
+    expect(fields.get('photos')).toEqual({ maxCount: 5 });
+    expect(fields.get('documents')).toEqual({ maxCount: 1 }); // default
+  });
+
+  test('handleMultipartSingleFile should return expected structure', async () => {
+    const { handleMultipartSingleFile } =
+      await import('../src/multer/multipart/handlers/single-file');
+    const { MemoryStorage } =
+      await import('../src/multer/storage/memory-storage');
+
+    const storage = new MemoryStorage();
+    const options = { storage };
+
+    const file = new File(['content'], 'photo.jpg', { type: 'image/jpeg' });
+    const mockReq = {
+      body: { photo: file, title: 'My Photo' },
+      header: () => 'multipart/form-data',
+    } as unknown as THonoRequest;
+
+    const result = await handleMultipartSingleFile(mockReq, 'photo', options);
+
+    expect(result).toHaveProperty('body');
+    expect(result).toHaveProperty('file');
+    expect(result).toHaveProperty('remove');
+    expect(result.file).toBeDefined();
+    expect(result.body.title).toBe('My Photo');
+
+    // Test remove function
+    await result.remove();
+  });
+
+  test('transformUploadOptions should provide defaults', async () => {
+    const { transformUploadOptions } =
+      await import('../src/multer/multipart/options');
+
+    const noOptions = transformUploadOptions();
+    expect(noOptions.storage).toBeDefined();
+
+    const withOptions = transformUploadOptions({ dest: '/tmp' });
+    expect(withOptions.storage).toBeDefined();
+    expect(withOptions.dest).toBe('/tmp');
+  });
+});