feat(backend): crud managers with pagination #19

Author: maniac-en

db/queries/endpoints.sql

@@ -16,10 +16,15 @@ RETURNING *;
 SELECT * FROM endpoints
 WHERE id = ? LIMIT 1;
 
--- name: ListEndpoints :many
+-- name: ListEndpointsPaginated :many
 SELECT * FROM endpoints
 WHERE collection_id = ?
-ORDER BY name;
+ORDER BY name
+LIMIT ? OFFSET ?;
+
+-- name: CountEndpointsByCollection :one
+SELECT COUNT(*) FROM endpoints
+WHERE collection_id = ?;
 
 -- name: UpdateEndpoint :one
 UPDATE endpoints

internal/collections/manager.go

@@ -104,7 +104,7 @@ func (c *CollectionsManager) List(ctx context.Context) ([]CollectionEntity, erro
 	return paginated.Collections, nil
 }
 
-func (c *CollectionsManager) ListPaginated(ctx context.Context, limit, offset int64) (*PaginatedCollections, error) {
+func (c *CollectionsManager) ListPaginated(ctx context.Context, limit, offset int) (*PaginatedCollections, error) {
 	log.Debug("listing paginated collections", "limit", limit, "offset", offset)
 
 	total, err := c.DB.CountCollections(ctx)
@@ -114,8 +114,8 @@ func (c *CollectionsManager) ListPaginated(ctx context.Context, limit, offset in
 	}
 
 	collections, err := c.DB.GetCollectionsPaginated(ctx, database.GetCollectionsPaginatedParams{
-		Limit:  limit,
-		Offset: offset,
+		Limit:  int64(limit),
+		Offset: int64(offset),
 	})
 	if err != nil {
 		log.Error("failed to get paginated collections", "limit", limit, "offset", offset, "error", err)
@@ -127,17 +127,12 @@ func (c *CollectionsManager) ListPaginated(ctx context.Context, limit, offset in
 		entities[i] = CollectionEntity{Collection: collection}
 	}
 
-	hasNext := offset+int64(len(collections)) < total
-	hasPrev := offset > 0
+	pagination := crud.CalculatePagination(total, limit, offset)
 
-	log.Debug("retrieved paginated collections", "total", total, "returned", len(entities), "has_next", hasNext, "has_prev", hasPrev)
-
-	return &PaginatedCollections{
-		Collections: entities,
-		Total:       total,
-		Offset:      offset,
-		Limit:       limit,
-		HasNext:     hasNext,
-		HasPrev:     hasPrev,
-	}, nil
+	result := &PaginatedCollections{
+		Collections:        entities,
+		PaginationMetadata: pagination,
+	}
+	log.Info("retrieved collections", "count", len(entities), "total", pagination.Total, "page", pagination.CurrentPage, "total_pages", pagination.TotalPages)
+	return result, nil
 }

internal/collections/manager_test.go

@@ -100,12 +100,12 @@ func TestCollectionsManagerCRUD(t *testing.T) {
 		for i := 1; i <= 5; i++ {
 			manager.Create(ctx, fmt.Sprintf("Pagination Test %d", i))
 		}
-		
+
 		paginated, err := manager.ListPaginated(ctx, 2, 0)
 		if err != nil {
 			t.Fatalf("ListPaginated failed: %v", err)
 		}
-		
+
 		if len(paginated.Collections) != 2 {
 			t.Errorf("Expected 2 collections, got %d", len(paginated.Collections))
 		}
@@ -118,7 +118,7 @@ func TestCollectionsManagerCRUD(t *testing.T) {
 		if paginated.HasPrev {
 			t.Error("Expected HasPrev to be false for offset 0")
 		}
-		
+
 		// Test second page
 		paginated2, err := manager.ListPaginated(ctx, 2, 2)
 		if err != nil {
@@ -155,4 +155,4 @@ func TestCollectionsManagerValidation(t *testing.T) {
 			t.Errorf("Expected ErrNotFound, got %v", err)
 		}
 	})
-}
+}

internal/collections/models.go

@@ -3,6 +3,7 @@ package collections
 import (
 	"time"
 
+	"github.com/maniac-en/req/internal/crud"
 	"github.com/maniac-en/req/internal/database"
 	"github.com/maniac-en/req/internal/log"
 )
@@ -43,9 +44,5 @@ type CollectionsManager struct {
 
 type PaginatedCollections struct {
 	Collections []CollectionEntity `json:"collections"`
-	Total       int64              `json:"total"`
-	Offset      int64              `json:"offset"`
-	Limit       int64              `json:"limit"`
-	HasNext     bool               `json:"has_next"`
-	HasPrev     bool               `json:"has_prev"`
-}
+	crud.PaginationMetadata
+}

internal/crud/interfaces.go

@@ -25,4 +25,31 @@ type Manager[T Entity] interface {
 	Update(ctx context.Context, id int64, name string) (T, error)
 	Delete(ctx context.Context, id int64) error
 	List(ctx context.Context) ([]T, error)
-}
+}
+
+type PaginationMetadata struct {
+	Total       int64 `json:"total"`
+	HasNext     bool  `json:"has_next"`
+	HasPrev     bool  `json:"has_prev"`
+	Limit       int   `json:"limit"`
+	Offset      int   `json:"offset"`
+	TotalPages  int   `json:"total_pages"`
+	CurrentPage int   `json:"current_page"`
+}
+
+func CalculatePagination(total int64, limit, offset int) PaginationMetadata {
+	totalPages := int((total + int64(limit) - 1) / int64(limit)) // Ceiling division
+	currentPage := (offset / limit) + 1
+	hasNext := (offset + limit) < int(total)
+	hasPrev := offset > 0
+
+	return PaginationMetadata{
+		Total:       total,
+		HasNext:     hasNext,
+		HasPrev:     hasPrev,
+		Limit:       limit,
+		Offset:      offset,
+		TotalPages:  totalPages,
+		CurrentPage: currentPage,
+	}
+}