@kiyasov/platform-hono 1.6.1 → 2.0.1

package/test/graphql-upload.test.ts

@@ -0,0 +1,509 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  processRequest,
+  ProcessRequestOptions,
+} from '../src/drivers/graphQLUpload/processRequest';
+import {
+  CapacitorStorage,
+  type CapacitorStorageFile,
+} from '../src/drivers/graphQLUpload/storage/capacitor-storage';
+import {
+  MemoryStorage,
+  type MemoryStorageFile,
+} from '../src/drivers/graphQLUpload/storage/memory-storage';
+import { Storage } from '../src/drivers/graphQLUpload/storage/storage';
+import { MemoryUploadFile, Upload } from '../src/drivers/graphQLUpload/Upload';
+import {
+  asContext,
+  asHonoRequest,
+  type MockContext,
+  type MockRequest,
+} from './helpers';
+
+describe('GraphQL Upload', () => {
+  describe('Upload class', () => {
+    test('should create upload promise', () => {
+      const upload = new Upload();
+
+      expect(upload.promise).toBeInstanceOf(Promise);
+      expect(upload.resolve).toBeInstanceOf(Function);
+      expect(upload.reject).toBeInstanceOf(Function);
+      expect(upload.file).toBeUndefined();
+    });
+
+    test('should resolve upload with file', async () => {
+      const upload = new Upload();
+      const mockFile: MemoryUploadFile = {
+        fieldName: 'file',
+        originalFilename: 'test.txt',
+        mimetype: 'text/plain',
+        encoding: '7bit',
+        size: 4,
+        uploadedAt: new Date().toISOString(),
+      };
+
+      upload.resolve(mockFile);
+
+      const result = await upload.promise;
+      expect(result).toEqual(mockFile);
+      expect(upload.file).toEqual(mockFile);
+    });
+
+    test('should reject upload with error', async () => {
+      const upload = new Upload();
+      const error = new Error('Upload failed');
+
+      upload.reject(error);
+
+      let caughtError: Error | undefined;
+      try {
+        await upload.promise;
+      } catch (e) {
+        caughtError = e as Error;
+      }
+
+      expect(caughtError).toEqual(error);
+    });
+
+    test('should handle unhandled rejections gracefully', async () => {
+      const upload = new Upload();
+      upload.reject(new Error('Test error'));
+
+      // Should not throw unhandled rejection
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('MemoryStorage', () => {
+    test('should store file in memory', async () => {
+      const storage = new MemoryStorage();
+      const file = new File(['test content'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockReq: MockRequest = {
+        header: () => 'multipart/form-data',
+      };
+
+      const result = await storage.handleFile(
+        file,
+        asHonoRequest(mockReq),
+        'file',
+      );
+
+      expect(result.fieldName).toBe('file');
+      expect(result.originalFilename).toBe('test.txt');
+      expect(result.mimetype).toContain('text/plain');
+      expect(result.encoding).toBe('7bit');
+      expect(result.size).toBe(12);
+      expect(result.uploadedAt).toBeDefined();
+      expect((result as MemoryStorageFile).buffer).toBeInstanceOf(Buffer);
+      expect((result as MemoryStorageFile).buffer?.toString()).toBe(
+        'test content',
+      );
+    });
+
+    test('should enforce max file size', async () => {
+      const storage = new MemoryStorage({ maxSize: 10 });
+      const file = new File(['this is too large'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockReq: MockRequest = {
+        header: () => 'multipart/form-data',
+      };
+
+      let errorThrown = false;
+      try {
+        await storage.handleFile(file, asHonoRequest(mockReq), 'file');
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          'exceeds maximum size',
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+
+    test('should remove file buffer', async () => {
+      const storage = new MemoryStorage();
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+
+      const mockReq: MockRequest = {
+        header: () => 'multipart/form-data',
+      };
+
+      const result = await storage.handleFile(
+        file,
+        asHonoRequest(mockReq),
+        'file',
+      );
+
+      expect((result as MemoryStorageFile).buffer).toBeDefined();
+
+      await storage.removeFile(result);
+
+      // Buffer should be deleted
+      expect((result as MemoryStorageFile).buffer).toBeUndefined();
+    });
+  });
+
+  describe('CapacitorStorage', () => {
+    test('should store file with capacitor', async () => {
+      const storage = new CapacitorStorage();
+      const file = new File(['test content'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockReq: MockRequest = {
+        header: () => 'multipart/form-data',
+      };
+
+      const result = await storage.handleFile(
+        file,
+        asHonoRequest(mockReq),
+        'file',
+      );
+
+      expect(result.fieldName).toBe('file');
+      expect(result.originalFilename).toBe('test.txt');
+      expect(result.mimetype).toContain('text/plain');
+      expect(result.encoding).toBe('7bit');
+      expect(result.size).toBe(12);
+      expect(result.uploadedAt).toBeDefined();
+      expect(result.capacitor).toBeDefined();
+      expect(result.createReadStream).toBeInstanceOf(Function);
+    });
+
+    test('should enforce max file size', async () => {
+      const storage = new CapacitorStorage({ maxSize: 10 });
+      const file = new File(['this is too large'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockReq: MockRequest = {
+        header: () => 'multipart/form-data',
+      };
+
+      let errorThrown = false;
+      try {
+        await storage.handleFile(file, asHonoRequest(mockReq), 'file');
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          'exceeds maximum size',
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+
+    test('should release capacitor on remove', async () => {
+      const storage = new CapacitorStorage();
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+
+      const mockReq: MockRequest = {
+        header: () => 'multipart/form-data',
+      };
+
+      const result = await storage.handleFile(
+        file,
+        asHonoRequest(mockReq),
+        'file',
+      );
+
+      // Release should not throw
+      await storage.removeFile(result);
+
+      // Verify capacitor is released (no throw = success)
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('processRequest', () => {
+    test('should process single file upload', async () => {
+      const file = new File(['test content'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              query: 'mutation ($file: Upload!) { uploadFile(file: $file) }',
+              variables: { file: null },
+            }),
+            map: JSON.stringify({ '0': ['variables.file'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const result = await processRequest(asContext(mockCtx));
+
+      expect((result as { variables: unknown }).variables).toBeDefined();
+      expect(
+        (result as { variables: { file: unknown } }).variables.file,
+      ).toBeInstanceOf(Upload);
+    });
+
+    test('should process multiple files upload', async () => {
+      const file1 = new File(['content1'], 'file1.txt', {
+        type: 'text/plain',
+      });
+      const file2 = new File(['content2'], 'file2.txt', {
+        type: 'text/plain',
+      });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              query:
+                'mutation ($files: [Upload!]!) { uploadFiles(files: $files) }',
+              variables: { files: [null, null] },
+            }),
+            map: JSON.stringify({
+              '0': ['variables.files.0'],
+              '1': ['variables.files.1'],
+            }),
+            '0': file1,
+            '1': file2,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const result = await processRequest(asContext(mockCtx));
+
+      expect((result as { variables: unknown }).variables).toBeDefined();
+      expect(
+        (result as { variables: { files: unknown[] } }).variables.files,
+      ).toHaveLength(2);
+      expect(
+        (result as { variables: { files: unknown[] } }).variables.files[0],
+      ).toBeInstanceOf(Upload);
+      expect(
+        (result as { variables: { files: unknown[] } }).variables.files[1],
+      ).toBeInstanceOf(Upload);
+
+      // Verify fieldname is extracted correctly from array paths
+      const upload1 = (result as { variables: { files: Upload[] } }).variables
+        .files[0] as Upload;
+      const upload2 = (result as { variables: { files: Upload[] } }).variables
+        .files[1] as Upload;
+      const uploadedFile1 = await upload1.promise;
+      const uploadedFile2 = await upload2.promise;
+
+      expect(uploadedFile1.fieldName).toBe('files');
+      expect(uploadedFile1.fieldName).toBe('files');
+      expect(uploadedFile2.fieldName).toBe('files');
+      expect(uploadedFile2.fieldName).toBe('files');
+    });
+
+    test('should use CapacitorStorage by default', async () => {
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              variables: { file: null },
+            }),
+            map: JSON.stringify({ '0': ['variables.file'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const result = await processRequest(asContext(mockCtx));
+      const upload = (result as { variables: { file: Upload } }).variables
+        .file as Upload;
+      const uploadedFile = await upload.promise;
+
+      // Default storage should be CapacitorStorage
+      expect((uploadedFile as CapacitorStorageFile).capacitor).toBeDefined();
+      expect(uploadedFile.createReadStream).toBeInstanceOf(Function);
+      // fieldName should be extracted from GraphQL path, not from multipart index
+      expect(uploadedFile.fieldName).toBe('file');
+      expect(uploadedFile.fieldName).toBe('file');
+    });
+
+    test('should use CapacitorStorage when tmpDir is specified', async () => {
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              variables: { file: null },
+            }),
+            map: JSON.stringify({ '0': ['variables.file'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const options: ProcessRequestOptions = {
+        tmpDir: '/tmp',
+      };
+
+      const result = await processRequest(asContext(mockCtx), options);
+      const upload = (result as { variables: { file: Upload } }).variables
+        .file as Upload;
+      const uploadedFile = await upload.promise;
+
+      expect((uploadedFile as CapacitorStorageFile).capacitor).toBeDefined();
+    });
+
+    test('should use MemoryStorage when explicitly provided', async () => {
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              variables: { file: null },
+            }),
+            map: JSON.stringify({ '0': ['variables.file'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const options: ProcessRequestOptions = {
+        storage: new MemoryStorage(),
+      };
+
+      const result = await processRequest(asContext(mockCtx), options);
+      const upload = (result as { variables: { file: Upload } }).variables
+        .file as Upload;
+      const uploadedFile = await upload.promise;
+
+      // MemoryStorage should have buffer
+      expect((uploadedFile as MemoryStorageFile).buffer).toBeInstanceOf(Buffer);
+    });
+
+    test('should use custom storage when provided', async () => {
+      const customStorage: Storage<MemoryUploadFile> = {
+        async handleFile(file, _req, fieldName): Promise<MemoryUploadFile> {
+          return {
+            fieldName,
+            originalFilename: file.name,
+            mimetype: file.type,
+            encoding: '7bit',
+            size: file.size,
+            uploadedAt: new Date().toISOString(),
+          };
+        },
+        async removeFile() {
+          // Custom cleanup
+        },
+      };
+
+      const file = new File(['test'], 'test.txt', { type: 'text/plain' });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              variables: { file: null },
+            }),
+            map: JSON.stringify({ '0': ['variables.file'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const options: ProcessRequestOptions = {
+        storage: customStorage,
+      };
+
+      const result = await processRequest(asContext(mockCtx), options);
+      const upload = (result as { variables: { file: Upload } }).variables
+        .file as Upload;
+      const uploadedFile = await upload.promise;
+
+      expect(uploadedFile.originalFilename).toBe('test.txt');
+    });
+
+    test('should enforce maxFileSize when specified', async () => {
+      const file = new File(['this content is too large'], 'test.txt', {
+        type: 'text/plain',
+      });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              variables: { file: null },
+            }),
+            map: JSON.stringify({ '0': ['variables.file'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const options: ProcessRequestOptions = {
+        maxFileSize: 10,
+      };
+
+      const result = await processRequest(asContext(mockCtx), options);
+      const upload = (result as { variables: { file: Upload } }).variables
+        .file as Upload;
+
+      let errorThrown = false;
+      try {
+        await upload.promise;
+      } catch (err) {
+        errorThrown = true;
+        expect(err instanceof Error && err.message).toContain(
+          'exceeds maximum size',
+        );
+      }
+
+      expect(errorThrown).toBe(true);
+    });
+
+    test('should handle complex nested paths', async () => {
+      const file = new File(['avatar'], 'avatar.jpg', {
+        type: 'image/jpeg',
+      });
+
+      const mockCtx: MockContext = {
+        req: {
+          parseBody: async () => ({
+            operations: JSON.stringify({
+              variables: {
+                user: {
+                  profile: {
+                    avatar: null,
+                  },
+                },
+              },
+            }),
+            map: JSON.stringify({ '0': ['variables.user.profile.avatar'] }),
+            '0': file,
+          }),
+          header: () => 'multipart/form-data',
+        },
+      };
+
+      const result = await processRequest(asContext(mockCtx));
+
+      expect(
+        (result as { variables: { user: { profile: { avatar: Upload } } } })
+          .variables.user.profile.avatar,
+      ).toBeInstanceOf(Upload);
+    });
+  });
+});

package/test/helpers.ts

@@ -0,0 +1,70 @@
+/**
+ * Test helper types and utilities
+ */
+
+import { HonoRequest } from 'hono';
+import { Context } from 'hono';
+
+/**
+ * Mock request for testing
+ */
+export type MockRequest = {
+  header: (name: string) => string | undefined;
+};
+
+/**
+ * Mock context for testing
+ */
+export type MockContext = {
+  req: {
+    parseBody: () => Promise<Record<string, unknown>>;
+    header: (name: string) => string | undefined;
+  };
+};
+
+/**
+ * Create a mock Hono request
+ */
+export function createMockRequest(
+  overrides?: Partial<MockRequest>,
+): MockRequest {
+  return {
+    header: (name: string) => {
+      if (name === 'content-type') return 'multipart/form-data';
+      return undefined;
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock Hono context
+ */
+export function createMockContext(
+  overrides?: Partial<MockContext>,
+): MockContext {
+  return {
+    req: {
+      parseBody: async () => ({}),
+      header: (name: string) => {
+        if (name === 'content-type') return 'multipart/form-data';
+        return undefined;
+      },
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Cast mock request to HonoRequest
+ */
+export function asHonoRequest(mock: MockRequest): HonoRequest {
+  return mock as unknown as HonoRequest;
+}
+
+/**
+ * Cast mock context to Context
+ */
+export function asContext(mock: MockContext): Context {
+  return mock as unknown as Context;
+}