feat: Enhance filtering and pagination capabilities in Devlog API and context

Author: tikazyq

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

@@ -526,25 +526,83 @@ export class DevlogService {
     }
 
     // Apply status filter
-    if (projectFilter.status) {
+    if (projectFilter.status && projectFilter.status.length > 0) {
       queryBuilder.andWhere('devlog.status IN (:...statuses)', { statuses: projectFilter.status });
     }
 
+    // Apply type filter
+    if (projectFilter.type && projectFilter.type.length > 0) {
+      queryBuilder.andWhere('devlog.type IN (:...types)', { types: projectFilter.type });
+    }
+
     // Apply priority filter
-    if (projectFilter.priority) {
+    if (projectFilter.priority && projectFilter.priority.length > 0) {
       queryBuilder.andWhere('devlog.priority IN (:...priorities)', {
         priorities: projectFilter.priority,
       });
     }
 
-    // Apply pagination
-    const pagination = projectFilter.pagination || { page: 1, limit: 20 };
+    // Apply assignee filter
+    if (projectFilter.assignee !== undefined) {
+      if (projectFilter.assignee === null) {
+        queryBuilder.andWhere('devlog.assignee IS NULL');
+      } else {
+        queryBuilder.andWhere('devlog.assignee = :assignee', { assignee: projectFilter.assignee });
+      }
+    }
+
+    // Apply archived filter
+    if (projectFilter.archived !== undefined) {
+      queryBuilder.andWhere('devlog.archived = :archived', { archived: projectFilter.archived });
+    }
+
+    // Apply date range filters
+    if (projectFilter.fromDate) {
+      queryBuilder.andWhere('devlog.createdAt >= :fromDate', { fromDate: projectFilter.fromDate });
+    }
+    if (projectFilter.toDate) {
+      queryBuilder.andWhere('devlog.createdAt <= :toDate', { toDate: projectFilter.toDate });
+    }
+
+    // Apply search filter (if not already applied by search method)
+    if (projectFilter.search && !queryBuilder.getQueryAndParameters()[0].includes('LIKE')) {
+      queryBuilder.andWhere(
+        '(devlog.title LIKE :search OR devlog.description LIKE :search OR devlog.businessContext LIKE :search OR devlog.technicalContext LIKE :search)',
+        { search: `%${projectFilter.search}%` },
+      );
+    }
+
+    // Apply pagination and sorting
+    const pagination = projectFilter.pagination || {
+      page: 1,
+      limit: 20,
+      sortBy: 'updatedAt',
+      sortOrder: 'desc',
+    };
     const page = pagination.page || 1;
     const limit = pagination.limit || 20;
     const offset = (page - 1) * limit;
+    const sortBy = pagination.sortBy || 'updatedAt';
+    const sortOrder = pagination.sortOrder || 'desc';
 
     queryBuilder.skip(offset).take(limit);
-    queryBuilder.orderBy('devlog.updatedAt', 'DESC');
+
+    // Apply sorting
+    const validSortColumns = [
+      'id',
+      'title',
+      'type',
+      'status',
+      'priority',
+      'createdAt',
+      'updatedAt',
+      'closedAt',
+    ];
+    if (validSortColumns.includes(sortBy)) {
+      queryBuilder.orderBy(`devlog.${sortBy}`, sortOrder.toUpperCase() as 'ASC' | 'DESC');
+    } else {
+      queryBuilder.orderBy('devlog.updatedAt', 'DESC');
+    }
 
     const [entities, total] = await queryBuilder.getManyAndCount();
     const entries = entities.map((entity) => entity.toDevlogEntry());

packages/web/app/api/projects/[id]/devlogs/route.ts

@@ -51,15 +51,38 @@ export async function GET(request: NextRequest, { params }: { params: { id: stri
     if (queryData.priority) filter.priority = [queryData.priority];
     if (queryData.assignee) filter.assignee = queryData.assignee;
     if (queryData.archived !== undefined) filter.archived = queryData.archived;
-
-    // Pagination
-    if (queryData.limit || queryData.offset) {
-      filter.pagination = {
-        page: queryData.offset ? Math.floor(queryData.offset / (queryData.limit || 20)) + 1 : 1,
-        limit: queryData.limit || 20,
-      };
+    if (queryData.fromDate) filter.fromDate = queryData.fromDate;
+    if (queryData.toDate) filter.toDate = queryData.toDate;
+    if (queryData.search) filter.search = queryData.search;
+
+    // Handle special filter types for backwards compatibility
+    if (queryData.filterType) {
+      switch (queryData.filterType) {
+        case 'open':
+          filter.status = ['new', 'in-progress', 'blocked', 'in-review', 'testing'];
+          break;
+        case 'closed':
+          filter.status = ['done', 'cancelled'];
+          break;
+        case 'total':
+          // No status filter - show all
+          break;
+      }
     }
 
+    // Pagination - support both offset/limit and page-based pagination
+    const page =
+      queryData.page ||
+      (queryData.offset ? Math.floor(queryData.offset / (queryData.limit || 20)) + 1 : 1);
+    const limit = queryData.limit || 20;
+
+    filter.pagination = {
+      page,
+      limit,
+      sortBy: queryData.sortBy || 'updatedAt',
+      sortOrder: queryData.sortOrder || 'desc',
+    };
+
     let result;
     if (queryData.search) {
       result = await devlogService.search(queryData.search, filter);

packages/web/app/contexts/DevlogContext.tsx

@@ -158,16 +158,38 @@ export function DevlogProvider({ children }: { children: React.ReactNode }) {
     try {
       setLoading(true);
 
-      // Convert query filters to DevlogApiClient filters format
+      // Convert filters to DevlogFilters format for the API client
       const apiFilters: any = {};
 
+      // Convert array filters to single values (API expects single values currently)
+      if (filters.status && filters.status.length > 0) {
+        apiFilters.status = filters.status[0];
+      }
+      if (filters.type && filters.type.length > 0) {
+        apiFilters.type = filters.type[0];
+      }
+      if (filters.priority && filters.priority.length > 0) {
+        apiFilters.priority = filters.priority[0];
+      }
+
+      // Direct mappings
       if (filters.search) apiFilters.search = filters.search;
-      if (filters.status?.length === 1) apiFilters.status = filters.status[0];
-      if (filters.type?.length === 1) apiFilters.type = filters.type[0];
-      if (filters.priority?.length === 1) apiFilters.priority = filters.priority[0];
-      if (filters.pagination?.limit) apiFilters.limit = filters.pagination.limit;
-      if (filters.pagination?.page && filters.pagination?.limit) {
-        apiFilters.offset = (filters.pagination.page - 1) * filters.pagination.limit;
+      if (filters.assignee) apiFilters.assignee = filters.assignee;
+      if (filters.archived !== undefined) apiFilters.archived = filters.archived;
+      if (filters.fromDate) apiFilters.fromDate = filters.fromDate;
+      if (filters.toDate) apiFilters.toDate = filters.toDate;
+
+      // Handle filterType - only pass through valid values
+      if (filters.filterType && ['total', 'open', 'closed'].includes(filters.filterType)) {
+        apiFilters.filterType = filters.filterType;
+      }
+
+      // Pagination
+      if (filters.pagination) {
+        if (filters.pagination.page) apiFilters.page = filters.pagination.page;
+        if (filters.pagination.limit) apiFilters.limit = filters.pagination.limit;
+        if (filters.pagination.sortBy) apiFilters.sortBy = filters.pagination.sortBy;
+        if (filters.pagination.sortOrder) apiFilters.sortOrder = filters.pagination.sortOrder;
       }
 
       const data = await devlogApiClient.list(apiFilters);
@@ -227,54 +249,10 @@ export function DevlogProvider({ children }: { children: React.ReactNode }) {
     }
   }, [currentProject, devlogApiClient]);
 
-  // Client-side filtered devlogs
+  // All filtering is now handled server-side - simply return the devlogs from API
   const filteredDevlogs = useMemo(() => {
-    if (queryString) {
-      return devlogs;
-    }
-
-    let filtered = [...devlogs];
-
-    if (filters.status && filters.status.length > 0) {
-      filtered = filtered.filter((devlog) => filters.status!.includes(devlog.status));
-    }
-
-    if (filters.type && filters.type.length > 0) {
-      filtered = filtered.filter((devlog) => filters.type!.includes(devlog.type));
-    }
-
-    if (filters.priority && filters.priority.length > 0) {
-      filtered = filtered.filter((devlog) => filters.priority!.includes(devlog.priority));
-    }
-
-    if (filters.assignee) {
-      filtered = filtered.filter((devlog) => devlog.assignee === filters.assignee);
-    }
-
-    if (filters.fromDate) {
-      const fromDate = new Date(filters.fromDate);
-      fromDate.setHours(0, 0, 0, 0);
-      filtered = filtered.filter((devlog) => new Date(devlog.createdAt) >= fromDate);
-    }
-
-    if (filters.toDate) {
-      const toDate = new Date(filters.toDate);
-      toDate.setHours(23, 59, 59, 999);
-      filtered = filtered.filter((devlog) => new Date(devlog.createdAt) <= toDate);
-    }
-
-    if (filters.search) {
-      const searchQuery = filters.search.toLowerCase().trim();
-      filtered = filtered.filter((devlog) => {
-        const titleMatch = devlog.title.toLowerCase().includes(searchQuery);
-        const descriptionMatch = devlog.description.toLowerCase().includes(searchQuery);
-        // Note: Search in notes is handled separately by the notes API
-        return titleMatch || descriptionMatch;
-      });
-    }
-
-    return filtered;
-  }, [devlogs, filters, queryString]);
+    return devlogs;
+  }, [devlogs]);
 
   // CRUD operations
   const createDevlog = async (data: Partial<DevlogEntry>) => {