Refactor devlog services and schema for improved document handling and metadata management

Author: tikazyq

apps/web/app/api/projects/[name]/devlogs/[devlogId]/route.ts

@@ -107,10 +107,10 @@ export async function PUT(
       updatedEntry.closedAt = null;
     }
 
-    await devlogService.save(updatedEntry);
+    const result = await devlogService.update(devlogId, updatedEntry);
 
     // Transform and return updated entry
-    return createSuccessResponse(updatedEntry, { sseEventType: RealtimeEventType.DEVLOG_UPDATED });
+    return createSuccessResponse(result, { sseEventType: RealtimeEventType.DEVLOG_UPDATED });
   } catch (error) {
     console.error('Error updating devlog:', error);
     const message = error instanceof Error ? error.message : 'Failed to update devlog';

apps/web/app/api/projects/[name]/devlogs/route.ts

@@ -128,30 +128,17 @@ export async function POST(request: NextRequest, { params }: { params: { name: s
     const devlogService = PrismaDevlogService.getInstance(project.id);
     await devlogService.ensureInitialized();
 
-    // Add required fields and get next ID
-    const now = new Date().toISOString();
-    const nextId = await devlogService.getNextId();
-
+    // Prepare entry for creation
     const entry = {
       ...bodyValidation.data,
-      id: nextId,
-      createdAt: now,
-      updatedAt: now,
       projectId: project.id, // Ensure project context
     };
 
-    // Save the entry
-    await devlogService.save(entry);
-
-    // Retrieve the actual saved entry to ensure we have the correct ID
-    const savedEntry = await devlogService.get(nextId);
-
-    if (!savedEntry) {
-      throw new Error('Failed to retrieve saved devlog entry');
-    }
+    // Create the entry
+    const result = await devlogService.create(entry);
 
-    // Transform and return the actual saved devlog
-    return createSuccessResponse(savedEntry, {
+    // Transform and return the created devlog
+    return createSuccessResponse(result, {
       status: 201,
       sseEventType: RealtimeEventType.DEVLOG_CREATED,
     });

apps/web/app/api/projects/[name]/devlogs/search/route.ts

@@ -76,27 +76,27 @@ export async function GET(request: NextRequest, { params }: { params: { name: st
     if (queryData.fromDate) filter.fromDate = queryData.fromDate;
     if (queryData.toDate) filter.toDate = queryData.toDate;
 
-    // Perform the enhanced search using PrismaDevlogService
-    const result = await devlogService.searchWithRelevance(searchQuery, filter);
+    // Perform the search using PrismaDevlogService
+    const result = await devlogService.search(searchQuery, filter);
 
     // Transform the response to match the expected interface
     const response: SearchResponse = {
-      query: result.searchMeta.query,
+      query: searchQuery,
       results: result.items.map((item) => ({
-        entry: item.entry,
-        relevance: item.relevance,
-        matchedFields: item.matchedFields,
-        highlights: item.highlights,
+        entry: item,
+        relevance: 1.0, // Default relevance since we don't have relevance scoring yet
+        matchedFields: ['title', 'description'], // Default matched fields
+        highlights: undefined,
       })),
       pagination: {
         ...result.pagination,
         total: result.pagination.total ?? 0,
         totalPages: result.pagination.totalPages ?? 0,
       },
       searchMeta: {
-        searchTime: result.searchMeta.searchTime,
-        totalMatches: result.searchMeta.totalMatches,
-        appliedFilters: result.searchMeta.appliedFilters,
+        searchTime: 0, // Default search time since we don't track it yet
+        totalMatches: result.pagination.total ?? 0,
+        appliedFilters: filter,
       },
     };
 

apps/web/app/api/projects/[name]/devlogs/stats/timeseries/route.ts

@@ -51,7 +51,7 @@ export const GET = withErrorHandling(
 
     // Get devlog service and time series stats
     const devlogService = await ServiceHelper.getPrismaDevlogService(project.id);
-    const stats = await devlogService.getTimeSeriesStats(project.id, timeSeriesRequest);
+    const stats = await devlogService.getTimeSeries(timeSeriesRequest);
 
     return createSuccessResponse(stats);
   },

apps/web/lib/realtime/realtime-service.ts

@@ -85,7 +85,7 @@ export class RealtimeService {
    */
   async connect(): Promise<void> {
     if (!this.initialized) {
-      await this.ensureInitialized();
+      await this.initialize();
     } else if (this.provider) {
       await this.provider.connect();
     }

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

@@ -283,7 +283,7 @@ export class PrismaDevlogService extends PrismaServiceBase {
   /**
    * List devlog entries with filtering and pagination
    */
-  async list(filter?: DevlogFilter, sort?: SortOptions, pagination?: { limit?: number; offset?: number }): Promise<PaginatedResult<DevlogEntry>> {
+  async list(filter?: DevlogFilter, pagination?: { limit?: number; offset?: number }, sort?: SortOptions): Promise<PaginatedResult<DevlogEntry>> {
     await this.ensureInitialized();
 
     try {
@@ -555,7 +555,19 @@ export class PrismaDevlogService extends PrismaServiceBase {
    */
   private mapPrismaToDevlogEntry(prismaEntry: PrismaDevlogEntry & {
     notes?: Array<{ id: string; timestamp: Date; category: string; content: string }>;
-    documents?: Array<{ id: string; title: string; content: string; contentType: string; createdAt: Date; updatedAt: Date }>;
+    documents?: Array<{ 
+      id: string; 
+      filename: string;
+      originalName: string;
+      mimeType: string;
+      size: number;
+      type: string;
+      textContent: string | null;
+      metadata: any;
+      uploadedBy: string | null;
+      createdAt: Date; 
+      updatedAt: Date;
+    }>;
   }): DevlogEntry {
     return {
       id: prismaEntry.id,
@@ -583,13 +595,15 @@ export class PrismaDevlogService extends PrismaServiceBase {
       documents: prismaEntry.documents?.map((doc) => ({
         id: doc.id,
         devlogId: prismaEntry.id,
-        filename: doc.title,
-        originalName: doc.title,
-        mimeType: doc.contentType,
-        size: 0, // Will need to calculate this
-        type: 'text' as any, // Will need to determine from contentType
-        content: doc.content,
+        filename: doc.filename,
+        originalName: doc.originalName,
+        mimeType: doc.mimeType,
+        size: doc.size,
+        type: doc.type as any,
+        content: doc.textContent || undefined,
+        metadata: doc.metadata || {},
         uploadedAt: doc.createdAt.toISOString(),
+        uploadedBy: doc.uploadedBy || undefined,
       })) || [],
     };
   }

packages/core/src/services/prisma-document-service.ts

@@ -110,27 +110,24 @@ export class PrismaDocumentService extends PrismaServiceBase {
       const documentType = this.determineDocumentType(file.mimeType, file.originalName);
       const textContent = this.extractTextContent(file.content, documentType);
 
-      // Store both text content and metadata as JSON in the content field
-      const documentContent = JSON.stringify({
-        originalName: file.originalName,
-        mimeType: file.mimeType,
-        size: file.size,
-        type: documentType,
-        uploadedBy,
-        metadata: metadata || {},
-        textContent: textContent || '',
-        binaryContent: Buffer.isBuffer(file.content) 
-          ? file.content.toString('base64')
-          : Buffer.from(file.content, 'utf-8').toString('base64')
-      });
+      // Prepare binary content
+      const binaryContent = Buffer.isBuffer(file.content) 
+        ? file.content
+        : Buffer.from(file.content, 'utf-8');
 
       const document = await this.prismaClient!.devlogDocument.create({
         data: {
           id: documentId,
           devlogId: Number(devlogId),
-          title: file.originalName,
-          content: documentContent,
-          contentType: file.mimeType,
+          filename: documentId,
+          originalName: file.originalName,
+          mimeType: file.mimeType,
+          size: file.size,
+          type: documentType,
+          textContent: textContent || null,
+          binaryContent: binaryContent,
+          metadata: metadata || {},
+          uploadedBy: uploadedBy || null,
         },
       });
 
@@ -202,24 +199,10 @@ export class PrismaDocumentService extends PrismaServiceBase {
     try {
       const document = await this.prismaClient!.devlogDocument.findUnique({
         where: { id: documentId },
-        select: { content: true },
+        select: { binaryContent: true },
       });
 
-      if (!document?.content) {
-        return null;
-      }
-
-      try {
-        const parsedContent = JSON.parse(document.content);
-        if (parsedContent.binaryContent) {
-          return Buffer.from(parsedContent.binaryContent, 'base64');
-        }
-      } catch {
-        // If content is not JSON, treat as plain text
-        return Buffer.from(document.content, 'utf-8');
-      }
-
-      return null;
+      return document?.binaryContent ? Buffer.from(document.binaryContent) : null;
     } catch (error) {
       console.error('[DocumentService] Failed to get document content:', error);
       throw new Error(`Failed to get document content: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -249,13 +232,14 @@ export class PrismaDocumentService extends PrismaServiceBase {
     try {
       const where: any = {
         OR: [
-          { title: { contains: query, mode: 'insensitive' } },
-          { content: { contains: query, mode: 'insensitive' } },
+          { originalName: { contains: query, mode: 'insensitive' } },
+          { textContent: { contains: query, mode: 'insensitive' } },
         ],
       };
 
       if (options?.devlogId) where.devlogId = Number(options.devlogId);
-      if (options?.mimeType) where.contentType = { contains: options.mimeType };
+      if (options?.type) where.type = options.type;
+      if (options?.mimeType) where.mimeType = { contains: options.mimeType };
 
       const [documents, total] = await Promise.all([
         this.prismaClient!.devlogDocument.findMany({
@@ -309,19 +293,13 @@ export class PrismaDocumentService extends PrismaServiceBase {
         throw new Error('Document not found');
       }
 
-      // Parse existing content and update metadata
-      let parsedContent;
-      try {
-        parsedContent = JSON.parse(existingDoc.content);
-      } catch {
-        parsedContent = { metadata: {} };
-      }
-
-      parsedContent.metadata = { ...parsedContent.metadata, ...metadata };
+      // Merge with existing metadata
+      const existingMetadata = existingDoc.metadata as Record<string, any> || {};
+      const updatedMetadata = { ...existingMetadata, ...metadata };
 
       const document = await this.prismaClient!.devlogDocument.update({
         where: { id: documentId },
-        data: { content: JSON.stringify(parsedContent) },
+        data: { metadata: updatedMetadata },
       });
 
       return this.mapPrismaToDocument(document);
@@ -395,28 +373,17 @@ export class PrismaDocumentService extends PrismaServiceBase {
     try {
       const documents = await this.prismaClient!.devlogDocument.findMany({
         where: { devlogId: Number(devlogId) },
-        select: { content: true, contentType: true },
+        select: { size: true, type: true },
       });
 
       const totalDocuments = documents.length;
       let totalSize = 0;
       const typeBreakdown: Record<string, number> = {};
 
       documents.forEach(doc => {
-        try {
-          const parsedContent = JSON.parse(doc.content);
-          if (parsedContent.size) {
-            totalSize += parsedContent.size;
-          }
-          if (parsedContent.type) {
-            typeBreakdown[parsedContent.type] = (typeBreakdown[parsedContent.type] || 0) + 1;
-          }
-        } catch {
-          // If content is not JSON, estimate size and use contentType
-          totalSize += doc.content.length;
-          const documentType = this.determineDocumentType(doc.contentType, '');
-          typeBreakdown[documentType] = (typeBreakdown[documentType] || 0) + 1;
-        }
+        totalSize += doc.size;
+        const documentType = doc.type as DocumentType;
+        typeBreakdown[documentType] = (typeBreakdown[documentType] || 0) + 1;
       });
 
       return {
@@ -497,34 +464,18 @@ export class PrismaDocumentService extends PrismaServiceBase {
    * Map Prisma document entity to domain type
    */
   private mapPrismaToDocument(prismaDoc: any): DevlogDocument {
-    // Try to parse the content as JSON to extract structured data
-    let parsedContent: any = {};
-    try {
-      parsedContent = JSON.parse(prismaDoc.content);
-    } catch {
-      // If content is not JSON, treat as plain text content
-      parsedContent = {
-        textContent: prismaDoc.content,
-        originalName: prismaDoc.title,
-        mimeType: prismaDoc.contentType,
-        type: this.determineDocumentType(prismaDoc.contentType, prismaDoc.title),
-        size: prismaDoc.content.length,
-        metadata: {},
-      };
-    }
-
     return {
       id: prismaDoc.id,
       devlogId: prismaDoc.devlogId,
-      filename: prismaDoc.id, // Use ID as filename since we don't store it separately
-      originalName: parsedContent.originalName || prismaDoc.title,
-      mimeType: parsedContent.mimeType || prismaDoc.contentType,
-      size: parsedContent.size || prismaDoc.content.length,
-      type: parsedContent.type || this.determineDocumentType(prismaDoc.contentType, prismaDoc.title),
-      content: parsedContent.textContent || undefined,
-      metadata: parsedContent.metadata || {},
+      filename: prismaDoc.filename,
+      originalName: prismaDoc.originalName,
+      mimeType: prismaDoc.mimeType,
+      size: prismaDoc.size,
+      type: prismaDoc.type as DocumentType,
+      content: prismaDoc.textContent || undefined,
+      metadata: prismaDoc.metadata as Record<string, any> || {},
       uploadedAt: prismaDoc.createdAt?.toISOString() || new Date().toISOString(),
-      uploadedBy: parsedContent.uploadedBy || undefined,
+      uploadedBy: prismaDoc.uploadedBy || undefined,
     };
   }