Update DevlogService for document support and add tests

Co-authored-by: tikazyq <[email protected]>

Author: Copilot

.devlog/devlog.sqlite

@@ -0,0 +1,103 @@
+/**
+ * Document service tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { DocumentService } from '../document-service.js';
+import type { DevlogDocument } from '../../types/index.js';
+
+// Mock data for testing
+const mockFile = {
+  originalName: 'test-document.txt',
+  mimeType: 'text/plain',
+  size: 1024,
+  content: Buffer.from('This is a test document content', 'utf-8'),
+};
+
+const mockDevlogId = 1;
+
+describe('DocumentService', () => {
+  // Note: Database tests are skipped due to enum column compatibility issues with SQLite
+  // These tests focus on the business logic and type detection functionality
+
+  describe('Document Type Detection', () => {
+    it('should detect text documents correctly', () => {
+      const service = DocumentService.getInstance();
+      
+      // Access private method through any to test it
+      const detectType = (service as any).determineDocumentType.bind(service);
+      
+      expect(detectType('text/plain', '.txt')).toBe('text');
+      expect(detectType('text/markdown', '.md')).toBe('markdown');
+      expect(detectType('application/json', '.json')).toBe('json');
+      expect(detectType('text/csv', '.csv')).toBe('csv');
+    });
+
+    it('should detect code documents correctly', () => {
+      const service = DocumentService.getInstance();
+      const detectType = (service as any).determineDocumentType.bind(service);
+      
+      expect(detectType('text/plain', '.js')).toBe('code');
+      expect(detectType('text/plain', '.ts')).toBe('code');
+      expect(detectType('text/plain', '.py')).toBe('code');
+      expect(detectType('text/plain', '.java')).toBe('code');
+    });
+
+    it('should detect images correctly', () => {
+      const service = DocumentService.getInstance();
+      const detectType = (service as any).determineDocumentType.bind(service);
+      
+      expect(detectType('image/png', '.png')).toBe('image');
+      expect(detectType('image/jpeg', '.jpg')).toBe('image');
+      expect(detectType('image/gif', '.gif')).toBe('image');
+    });
+
+    it('should detect PDFs correctly', () => {
+      const service = DocumentService.getInstance();
+      const detectType = (service as any).determineDocumentType.bind(service);
+      
+      expect(detectType('application/pdf', '.pdf')).toBe('pdf');
+    });
+
+    it('should default to other for unknown types', () => {
+      const service = DocumentService.getInstance();
+      const detectType = (service as any).determineDocumentType.bind(service);
+      
+      expect(detectType('application/unknown', '.xyz')).toBe('other');
+    });
+  });
+
+  describe('Text Content Extraction', () => {
+    it('should identify text-based types correctly', () => {
+      const service = DocumentService.getInstance();
+      const isTextBased = (service as any).isTextBasedType.bind(service);
+      
+      expect(isTextBased('text')).toBe(true);
+      expect(isTextBased('markdown')).toBe(true);
+      expect(isTextBased('code')).toBe(true);
+      expect(isTextBased('json')).toBe(true);
+      expect(isTextBased('csv')).toBe(true);
+      expect(isTextBased('log')).toBe(true);
+      expect(isTextBased('config')).toBe(true);
+      
+      expect(isTextBased('image')).toBe(false);
+      expect(isTextBased('pdf')).toBe(false);
+      expect(isTextBased('other')).toBe(false);
+    });
+
+    it('should extract text content from strings and buffers', () => {
+      const service = DocumentService.getInstance();
+      const extractText = (service as any).extractTextContent.bind(service);
+      
+      const textContent = 'Hello, World!';
+      const bufferContent = Buffer.from(textContent, 'utf-8');
+      
+      expect(extractText(textContent, 'text')).toBe(textContent);
+      expect(extractText(bufferContent, 'text')).toBe(textContent);
+      expect(extractText(bufferContent, 'image')).toBe('');
+    });
+  });
+
+  // Note: More comprehensive integration tests would require a test database
+  // These tests focus on the business logic and type detection functionality
+});

packages/core/src/services/__tests__/document-service.test.ts

@@ -23,7 +23,7 @@ import type {
   TimeSeriesRequest,
   TimeSeriesStats,
 } from '../types/index.js';
-import { DevlogEntryEntity, DevlogNoteEntity } from '../entities/index.js';
+import { DevlogEntryEntity, DevlogNoteEntity, DevlogDocumentEntity } from '../entities/index.js';
 import { getDataSource } from '../utils/typeorm-config.js';
 import { getStorageType } from '../entities/decorators.js';
 import { DevlogValidator } from '../validation/devlog-schemas.js';
@@ -40,6 +40,7 @@ export class DevlogService {
   private database: DataSource;
   private devlogRepository: Repository<DevlogEntryEntity>;
   private noteRepository: Repository<DevlogNoteEntity>;
+  private documentRepository: Repository<DevlogDocumentEntity>;
   private pgTrgmAvailable: boolean = false;
   private initPromise: Promise<void> | null = null;
 
@@ -48,6 +49,7 @@ export class DevlogService {
     this.database = null as any; // Temporary placeholder
     this.devlogRepository = null as any; // Temporary placeholder
     this.noteRepository = null as any; // Temporary placeholder
+    this.documentRepository = null as any; // Temporary placeholder
   }
 
   /**
@@ -72,6 +74,7 @@ export class DevlogService {
         this.database = await getDataSource();
         this.devlogRepository = this.database.getRepository(DevlogEntryEntity);
         this.noteRepository = this.database.getRepository(DevlogNoteEntity);
+        this.documentRepository = this.database.getRepository(DevlogDocumentEntity);
         console.log(
           '[DevlogService] DataSource ready with entities:',
           this.database.entityMetadatas.length,
@@ -146,7 +149,7 @@ export class DevlogService {
     return existingInstance.service;
   }
 
-  async get(id: DevlogId, includeNotes = true): Promise<DevlogEntry | null> {
+  async get(id: DevlogId, includeNotes = true, includeDocuments = false): Promise<DevlogEntry | null> {
     await this.ensureInitialized();
 
     // Validate devlog ID
@@ -168,6 +171,11 @@ export class DevlogService {
       devlogEntry.notes = await this.getNotes(id);
     }
 
+    // Load documents if requested
+    if (includeDocuments) {
+      devlogEntry.documents = await this.getDocuments(id);
+    }
+
     return devlogEntry;
   }
 
@@ -205,6 +213,35 @@ export class DevlogService {
     }));
   }
 
+  /**
+   * Get documents for a specific devlog entry
+   */
+  async getDocuments(
+    devlogId: DevlogId,
+    limit?: number,
+  ): Promise<import('../types/index.js').DevlogDocument[]> {
+    await this.ensureInitialized();
+
+    // Validate devlog ID
+    const idValidation = DevlogValidator.validateDevlogId(devlogId);
+    if (!idValidation.success) {
+      throw new Error(`Invalid devlog ID: ${idValidation.errors.join(', ')}`);
+    }
+
+    const queryBuilder = this.documentRepository
+      .createQueryBuilder('document')
+      .where('document.devlogId = :devlogId', { devlogId: idValidation.data })
+      .orderBy('document.uploadedAt', 'DESC');
+
+    if (limit && limit > 0) {
+      queryBuilder.limit(limit);
+    }
+
+    const documentEntities = await queryBuilder.getMany();
+
+    return documentEntities.map((entity) => entity.toDevlogDocument());
+  }
+
   /**
    * Add a note to a devlog entry
    */

packages/core/src/services/devlog-service.ts

@@ -293,37 +293,37 @@ export class DocumentService {
       return 'pdf';
     }
 
-    // Text-based types
-    if (mimeType.startsWith('text/')) {
-      if (mimeType === 'text/markdown' || extension === '.md') {
-        return 'markdown';
-      }
-      if (extension === '.csv') {
-        return 'csv';
-      }
-      if (extension === '.log') {
-        return 'log';
-      }
-      return 'text';
-    }
-
-    // JSON
+    // JSON (check before text types)
     if (mimeType === 'application/json' || extension === '.json') {
       return 'json';
     }
 
-    // Code files
+    // Code files (check before general text types)
     const codeExtensions = ['.js', '.ts', '.py', '.java', '.cpp', '.c', '.go', '.rs', '.php', '.rb', '.swift', '.kt'];
     if (codeExtensions.includes(extension.toLowerCase())) {
       return 'code';
     }
 
-    // Config files
+    // Config files (check before general text types)
     const configExtensions = ['.env', '.conf', '.ini', '.yaml', '.yml', '.toml', '.properties'];
     if (configExtensions.includes(extension.toLowerCase())) {
       return 'config';
     }
 
+    // Text-based types (more specific checks first)
+    if (mimeType.startsWith('text/')) {
+      if (mimeType === 'text/markdown' || extension === '.md') {
+        return 'markdown';
+      }
+      if (extension === '.csv') {
+        return 'csv';
+      }
+      if (extension === '.log') {
+        return 'log';
+      }
+      return 'text';
+    }
+
     return 'other';
   }