Refactor document processing to remove file type parameter and enhance file type validation

Author: adamrefaey

backend/src/document-processor/controllers/document-processor.controller.ts

@@ -63,7 +63,6 @@ export class DocumentProcessorController {
       // Process the document
       const result = await this.documentProcessorService.processDocument(
         file.buffer,
-        file.mimetype,
         effectiveUserId,
       );
 

backend/src/document-processor/services/aws-textract.service.spec.ts

@@ -173,11 +173,7 @@ describe('AwsTextractService', () => {
 
   describe('extractText', () => {
     it('should extract text from an image', async () => {
-      const result = await service.extractText(
-        Buffer.from('test image content'),
-        'image/jpeg',
-        'user-123',
-      );
+      const result = await service.extractText(Buffer.from('test image content'), 'user-123');
 
       expect(result).toBeDefined();
       expect(result.rawText).toContain('This is a test medical report');
@@ -188,11 +184,7 @@ describe('AwsTextractService', () => {
     });
 
     it('should extract text from a PDF', async () => {
-      const result = await service.extractText(
-        Buffer.from('test pdf content'),
-        'application/pdf',
-        'user-123',
-      );
+      const result = await service.extractText(Buffer.from('test pdf content'), 'user-123');
 
       expect(result).toBeDefined();
       expect(result.rawText).toContain('This is a test medical report');
@@ -208,9 +200,9 @@ describe('AwsTextractService', () => {
       const userId = 'rate-limited-user';
 
       // Should throw rate limit exception
-      await expect(
-        service.extractText(Buffer.from('test content'), 'image/jpeg', userId),
-      ).rejects.toThrow('Too many requests');
+      await expect(service.extractText(Buffer.from('test content'), userId)).rejects.toThrow(
+        'Too many requests',
+      );
 
       // The textract API should not be called
       expect(mockTextractSend).not.toHaveBeenCalled();
@@ -222,11 +214,9 @@ describe('AwsTextractService', () => {
       const documents = [
         {
           buffer: Buffer.from('test image 1'),
-          type: 'image/jpeg',
         },
         {
           buffer: Buffer.from('test image 2'),
-          type: 'image/png',
         },
       ];
 
@@ -242,7 +232,6 @@ describe('AwsTextractService', () => {
     it('should throw an error if batch size exceeds maximum', async () => {
       const documents = Array(11).fill({
         buffer: Buffer.from('test image'),
-        type: 'image/jpeg',
       });
 
       await expect(service.processBatch(documents, 'user-123')).rejects.toThrow(

backend/src/document-processor/services/aws-textract.service.ts

@@ -81,15 +81,10 @@ export class AwsTextractService {
   /**
    * Extract text from a medical lab report image or PDF
    * @param fileBuffer The file buffer containing the image or PDF
-   * @param fileType The MIME type of the file (e.g., 'image/jpeg', 'application/pdf')
    * @param userId The authenticated user's ID for rate limiting
    * @returns Extracted text result with structured information
    */
-  async extractText(
-    fileBuffer: Buffer,
-    fileType: string,
-    userId: string,
-  ): Promise<ExtractedTextResult> {
+  async extractText(fileBuffer: Buffer, userId: string): Promise<ExtractedTextResult> {
     try {
       const startTime = Date.now();
 
@@ -99,17 +94,16 @@ export class AwsTextractService {
       }
 
       // 2. Validate file securely
-      validateFileSecurely(fileBuffer, fileType);
+      validateFileSecurely(fileBuffer);
 
       // Add diagnostic information about the document being processed
       this.logger.debug('Processing document', {
-        fileType,
         fileSize: `${(fileBuffer.length / 1024).toFixed(2)} KB`,
         contentHashPrefix: createHash('sha256').update(fileBuffer).digest('hex').substring(0, 10),
       });
 
       // 3. Process document
-      const result = await this.processDocument(fileBuffer, fileType);
+      const result = await this.processDocument(fileBuffer);
 
       // 4. Calculate processing time
       const processingTime = Date.now() - startTime;
@@ -125,7 +119,6 @@ export class AwsTextractService {
       // Log error securely without exposing sensitive details
       this.logger.error('Error processing document', {
         error: error instanceof Error ? error.message : 'Unknown error',
-        fileType,
         timestamp: new Date().toISOString(),
         userId: this.hashIdentifier(userId),
       });
@@ -143,13 +136,8 @@ export class AwsTextractService {
   /**
    * Process a document (image or PDF)
    */
-  private async processDocument(
-    documentBuffer: Buffer,
-    documentType: string,
-  ): Promise<ExtractedTextResult> {
-    this.logger.log(
-      `Processing ${documentType === 'application/pdf' ? 'PDF document' : 'single image'} with Textract`,
-    );
+  private async processDocument(documentBuffer: Buffer): Promise<ExtractedTextResult> {
+    this.logger.log(`Processing file with Textract`);
 
     // Use Analyze Document API for more comprehensive analysis
     const command = new AnalyzeDocumentCommand({
@@ -346,12 +334,12 @@ export class AwsTextractService {
 
   /**
    * Process multiple documents in batch
-   * @param documents Array of document buffers with their types
+   * @param documents Array of document buffers
    * @param userId The authenticated user's ID for rate limiting
    * @returns Array of extracted text results
    */
   async processBatch(
-    documents: Array<{ buffer: Buffer; type: string }>,
+    documents: Array<{ buffer: Buffer }>,
     userId: string,
   ): Promise<ExtractedTextResult[]> {
     // Validate batch size
@@ -365,12 +353,11 @@ export class AwsTextractService {
 
     for (const doc of documents) {
       try {
-        const result = await this.extractText(doc.buffer, doc.type, userId);
+        const result = await this.extractText(doc.buffer, userId);
         results.push(result);
       } catch (error) {
         this.logger.error('Error processing document in batch', {
           error: error instanceof Error ? error.message : 'Unknown error',
-          fileType: doc.type,
           fileSize: doc.buffer.length,
         });
 

backend/src/document-processor/services/document-processor.service.spec.ts

@@ -24,7 +24,6 @@ describe('DocumentProcessorService', () => {
     it('should extract text and analyze medical document', async () => {
       // Arrange
       const fileBuffer = Buffer.from('test');
-      const fileType = 'application/pdf';
       const userId = 'test-user';
 
       const extractedTextResult = {
@@ -67,10 +66,10 @@ describe('DocumentProcessorService', () => {
       );
 
       // Act
-      const result = await testService.processDocument(fileBuffer, fileType, userId);
+      const result = await testService.processDocument(fileBuffer, userId);
 
       // Assert
-      expect(testTextractService.extractText).toHaveBeenCalledWith(fileBuffer, fileType, userId);
+      expect(testTextractService.extractText).toHaveBeenCalledWith(fileBuffer, userId);
       expect(testBedrockService.analyzeMedicalDocument).toHaveBeenCalledWith(
         extractedTextResult.rawText,
         userId,
@@ -83,7 +82,6 @@ describe('DocumentProcessorService', () => {
         analysis: medicalAnalysis,
         simplifiedExplanation,
         processingMetadata: expect.objectContaining({
-          fileType,
           fileSize: fileBuffer.length,
         }),
       });
@@ -92,7 +90,6 @@ describe('DocumentProcessorService', () => {
     it('should throw BadRequestException when text extraction fails', async () => {
       // Arrange
       const fileBuffer = Buffer.from('test');
-      const fileType = 'application/pdf';
       const userId = 'test-user';
 
       // Create test-specific service with proper mocking
@@ -111,7 +108,7 @@ describe('DocumentProcessorService', () => {
       );
 
       // Act & Assert
-      await expect(testService.processDocument(fileBuffer, fileType, userId)).rejects.toThrow(
+      await expect(testService.processDocument(fileBuffer, userId)).rejects.toThrow(
         BadRequestException,
       );
     });
@@ -163,7 +160,6 @@ describe('DocumentProcessorService', () => {
         simplifiedExplanation: 'Simple explanation for document 1',
         processingMetadata: {
           processingTimeMs: 100,
-          fileType: 'application/pdf',
           fileSize: 4,
         },
       };
@@ -190,7 +186,6 @@ describe('DocumentProcessorService', () => {
         simplifiedExplanation: 'Simple explanation for document 2',
         processingMetadata: {
           processingTimeMs: 100,
-          fileType: 'image/jpeg',
           fileSize: 4,
         },
       };
@@ -204,18 +199,8 @@ describe('DocumentProcessorService', () => {
 
       // Assert
       expect(processDocumentSpy).toHaveBeenCalledTimes(2);
-      expect(processDocumentSpy).toHaveBeenNthCalledWith(
-        1,
-        documents[0].buffer,
-        documents[0].type,
-        userId,
-      );
-      expect(processDocumentSpy).toHaveBeenNthCalledWith(
-        2,
-        documents[1].buffer,
-        documents[1].type,
-        userId,
-      );
+      expect(processDocumentSpy).toHaveBeenNthCalledWith(1, documents[0].buffer, userId);
+      expect(processDocumentSpy).toHaveBeenNthCalledWith(2, documents[1].buffer, userId);
       expect(result).toHaveLength(2);
       expect(result[0]).toEqual(mockResult1);
       expect(result[1]).toEqual(mockResult2);

backend/src/document-processor/services/document-processor.service.ts

@@ -13,7 +13,6 @@ export interface ProcessedDocumentResult {
   simplifiedExplanation?: string;
   processingMetadata: {
     processingTimeMs: number;
-    fileType: string;
     fileSize: number;
   };
 }
@@ -35,26 +34,20 @@ export class DocumentProcessorService {
   /**
    * Process a medical document by extracting text and performing analysis
    * @param fileBuffer The file buffer containing the image or PDF
-   * @param fileType The MIME type of the file (e.g., 'image/jpeg', 'application/pdf')
    * @param userId The authenticated user's ID for rate limiting
    * @returns Processed document result with extracted text, analysis, and simplified explanation
    */
-  async processDocument(
-    fileBuffer: Buffer,
-    fileType: string,
-    userId: string,
-  ): Promise<ProcessedDocumentResult> {
+  async processDocument(fileBuffer: Buffer, userId: string): Promise<ProcessedDocumentResult> {
     try {
       const startTime = Date.now();
 
       this.logger.log('Starting document processing', {
-        fileType,
         fileSize: `${(fileBuffer.length / 1024).toFixed(2)} KB`,
         userId: this.hashIdentifier(userId),
       });
 
       // Step 1: Extract text from document using AWS Textract
-      const extractedText = await this.textractService.extractText(fileBuffer, fileType, userId);
+      const extractedText = await this.textractService.extractText(fileBuffer, userId);
 
       this.logger.log('Text extraction completed', {
         lineCount: extractedText.lines.length,
@@ -103,15 +96,13 @@ export class DocumentProcessorService {
         simplifiedExplanation,
         processingMetadata: {
           processingTimeMs: processingTime,
-          fileType,
           fileSize: fileBuffer.length,
         },
       };
     } catch (error: unknown) {
       // Log error securely without exposing sensitive details
       this.logger.error('Error processing document', {
         error: error instanceof Error ? error.message : 'Unknown error',
-        fileType,
         timestamp: new Date().toISOString(),
         userId: this.hashIdentifier(userId),
       });
@@ -146,12 +137,11 @@ export class DocumentProcessorService {
 
     for (const doc of documents) {
       try {
-        const result = await this.processDocument(doc.buffer, doc.type, userId);
+        const result = await this.processDocument(doc.buffer, userId);
         results.push(result);
       } catch (error) {
         this.logger.error('Error processing document in batch', {
           error: error instanceof Error ? error.message : 'Unknown error',
-          fileType: doc.type,
           fileSize: doc.buffer.length,
         });
 
@@ -178,7 +168,6 @@ export class DocumentProcessorService {
           simplifiedExplanation: undefined,
           processingMetadata: {
             processingTimeMs: 0,
-            fileType: doc.type,
             fileSize: doc.buffer.length,
           },
         });

backend/src/services/README.md

@@ -30,7 +30,6 @@ export interface ProcessedDocumentResult {
   analysis: MedicalDocumentAnalysis;
   processingMetadata: {
     processingTimeMs: number;
-    fileType: string;
     fileSize: number;
   };
 }
@@ -133,7 +132,6 @@ curl -X POST \
   },
   "processingMetadata": {
     "processingTimeMs": 2345,
-    "fileType": "application/pdf",
     "fileSize": 12345
   }
 }
@@ -146,11 +144,10 @@ curl -X POST \
 constructor(private readonly documentProcessorService: DocumentProcessorService) {}
 
 // Process a document
-async processReport(fileBuffer: Buffer, fileType: string, userId: string) {
+async processReport(fileBuffer: Buffer, userId: string) {
   try {
     const result = await this.documentProcessorService.processDocument(
       fileBuffer,
-      fileType,
       userId
     );
 
@@ -179,8 +176,8 @@ The service supports batch processing of multiple documents:
 ```typescript
 const results = await documentProcessorService.processBatch(
   [
-    { buffer: fileBuffer1, type: fileType1 },
-    { buffer: fileBuffer2, type: fileType2 }
+    { buffer: fileBuffer1 },
+    { buffer: fileBuffer2 }
   ],
   userId
 );

backend/src/utils/security.utils.ts

@@ -86,8 +86,23 @@ const validateFileType = (buffer: Buffer, mimeType: string): boolean => {
  * @param buffer The file buffer to validate
  * @param mimeType The declared MIME type of the file
  */
-export const validateFileSecurely = (buffer: Buffer, mimeType: string): void => {
+export const validateFileSecurely = (buffer: Buffer): void => {
   const logger = new Logger('SecurityUtils');
+  // get file mime type correctly
+  let mimeType = buffer.toString('hex', 0, 4).toUpperCase();
+  if (mimeType.startsWith('FFD8')) {
+    mimeType = 'image/jpeg';
+  } else if (mimeType.startsWith('89504E47')) {
+    mimeType = 'image/png';
+  } else if (mimeType.startsWith('00000020667479706865696300')) {
+    mimeType = 'image/heic';
+  } else if (mimeType.startsWith('0000001C667479706D696631')) {
+    mimeType = 'image/heif';
+  } else if (mimeType.startsWith('25504446')) {
+    mimeType = 'application/pdf';
+  } else {
+    throw new BadRequestException('Unsupported file type');
+  }
 
   // 1. Check if file type is allowed
   if (!ALLOWED_MIME_TYPES.has(mimeType)) {