Complete tasks 4.1-4.2: Page management service and HTTP endpoints

- Implemented PageService with full CRUD operations
- Added GetPages, CreatePage, UpdatePage, DeletePage, ReorderPages methods
- Cascade deletion of widgets when page is deleted
- Prevention of last page deletion
- Created page HTTP endpoints (GET, POST, PUT, DELETE, reorder)
- HTMX-friendly HTML fragment responses
- Comprehensive unit tests for service and handlers
- Updated dashboard to use PageService and create default pages

internal/services/interfaces.go

@@ -0,0 +1,17 @@
+package services
+
+import (
+	"context"
+
+	"custom-start-page/internal/models"
+)
+
+// PageServiceInterface defines the interface for page operations
+type PageServiceInterface interface {
+	GetPages(ctx context.Context, userID string) ([]*models.Page, error)
+	CreatePage(ctx context.Context, userID, name string) (*models.Page, error)
+	CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error)
+	UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error)
+	DeletePage(ctx context.Context, userID, pageID string) error
+	ReorderPages(ctx context.Context, userID string, pageOrder []string) error
+}

internal/services/page_service.go

@@ -0,0 +1,275 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
+	"github.com/google/uuid"
+
+	"custom-start-page/internal/models"
+	"custom-start-page/internal/storage"
+)
+
+// PageService handles all page-related business logic
+type PageService struct {
+	db *storage.DynamoDBClient
+}
+
+// NewPageService creates a new PageService instance
+func NewPageService(db *storage.DynamoDBClient) *PageService {
+	return &PageService{
+		db: db,
+	}
+}
+
+// GetPages retrieves all pages for a user in display order
+func (s *PageService) GetPages(ctx context.Context, userID string) ([]*models.Page, error) {
+	input := &dynamodb.QueryInput{
+		TableName:              aws.String("Pages"),
+		KeyConditionExpression: aws.String("user_id = :user_id"),
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":user_id": &types.AttributeValueMemberS{Value: userID},
+		},
+	}
+
+	output, err := s.db.Query(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query pages: %w", err)
+	}
+
+	var pages []*models.Page
+	err = attributevalue.UnmarshalListOfMaps(output.Items, &pages)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal pages: %w", err)
+	}
+
+	// Sort by order field
+	sortPagesByOrder(pages)
+
+	return pages, nil
+}
+
+// CreatePage creates a new page for a user
+func (s *PageService) CreatePage(ctx context.Context, userID, name string) (*models.Page, error) {
+	// Get existing pages to determine the next order
+	existingPages, err := s.GetPages(ctx, userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get existing pages: %w", err)
+	}
+
+	nextOrder := len(existingPages)
+
+	page := &models.Page{
+		ID:        uuid.New().String(),
+		UserID:    userID,
+		Name:      name,
+		Order:     nextOrder,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	item, err := attributevalue.MarshalMap(page)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal page: %w", err)
+	}
+
+	input := &dynamodb.PutItemInput{
+		TableName: aws.String("Pages"),
+		Item:      item,
+	}
+
+	err = s.db.PutItem(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create page: %w", err)
+	}
+
+	return page, nil
+}
+
+// CreateDefaultPage creates the default "Home" page for new users
+func (s *PageService) CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) {
+	return s.CreatePage(ctx, userID, "Home")
+}
+
+// UpdatePage updates a page's name or order
+func (s *PageService) UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) {
+	now := time.Now()
+
+	input := &dynamodb.UpdateItemInput{
+		TableName: aws.String("Pages"),
+		Key: map[string]types.AttributeValue{
+			"user_id": &types.AttributeValueMemberS{Value: userID},
+			"page_id": &types.AttributeValueMemberS{Value: pageID},
+		},
+		UpdateExpression: aws.String("SET #name = :name, updated_at = :updated_at"),
+		ExpressionAttributeNames: map[string]string{
+			"#name": "name",
+		},
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":name":       &types.AttributeValueMemberS{Value: name},
+			":updated_at": &types.AttributeValueMemberS{Value: now.Format(time.RFC3339)},
+		},
+		ReturnValues: types.ReturnValueAllNew,
+	}
+
+	output, err := s.db.UpdateItem(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to update page: %w", err)
+	}
+
+	var page models.Page
+	err = attributevalue.UnmarshalMap(output.Attributes, &page)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal updated page: %w", err)
+	}
+
+	return &page, nil
+}
+
+// DeletePage deletes a page and all associated widgets
+func (s *PageService) DeletePage(ctx context.Context, userID, pageID string) error {
+	// Check if this is the last page
+	pages, err := s.GetPages(ctx, userID)
+	if err != nil {
+		return fmt.Errorf("failed to get pages: %w", err)
+	}
+
+	if len(pages) <= 1 {
+		return fmt.Errorf("cannot delete the last page")
+	}
+
+	// Get all widgets for this page
+	widgetsInput := &dynamodb.QueryInput{
+		TableName:              aws.String("Widgets"),
+		KeyConditionExpression: aws.String("page_id = :page_id"),
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":page_id": &types.AttributeValueMemberS{Value: pageID},
+		},
+	}
+
+	widgetsOutput, err := s.db.Query(ctx, widgetsInput)
+	if err != nil {
+		return fmt.Errorf("failed to query widgets: %w", err)
+	}
+
+	// Delete all widgets in batches
+	if len(widgetsOutput.Items) > 0 {
+		var writeRequests []types.WriteRequest
+		for _, item := range widgetsOutput.Items {
+			writeRequests = append(writeRequests, types.WriteRequest{
+				DeleteRequest: &types.DeleteRequest{
+					Key: map[string]types.AttributeValue{
+						"page_id":   item["page_id"],
+						"widget_id": item["widget_id"],
+					},
+				},
+			})
+		}
+
+		// Process in batches of 25 (DynamoDB limit)
+		for i := 0; i < len(writeRequests); i += 25 {
+			end := i + 25
+			if end > len(writeRequests) {
+				end = len(writeRequests)
+			}
+
+			batchInput := &dynamodb.BatchWriteItemInput{
+				RequestItems: map[string][]types.WriteRequest{
+					"Widgets": writeRequests[i:end],
+				},
+			}
+
+			err = s.db.BatchWriteItems(ctx, batchInput)
+			if err != nil {
+				return fmt.Errorf("failed to delete widgets: %w", err)
+			}
+		}
+	}
+
+	// Delete the page
+	deleteInput := &dynamodb.DeleteItemInput{
+		TableName: aws.String("Pages"),
+		Key: map[string]types.AttributeValue{
+			"user_id": &types.AttributeValueMemberS{Value: userID},
+			"page_id": &types.AttributeValueMemberS{Value: pageID},
+		},
+	}
+
+	err = s.db.DeleteItem(ctx, deleteInput)
+	if err != nil {
+		return fmt.Errorf("failed to delete page: %w", err)
+	}
+
+	return nil
+}
+
+// ReorderPages updates the display order of pages
+func (s *PageService) ReorderPages(ctx context.Context, userID string, pageOrder []string) error {
+	// Validate that all pages exist and belong to the user
+	existingPages, err := s.GetPages(ctx, userID)
+	if err != nil {
+		return fmt.Errorf("failed to get existing pages: %w", err)
+	}
+
+	// Create a map for quick lookup
+	pageMap := make(map[string]*models.Page)
+	for _, page := range existingPages {
+		pageMap[page.ID] = page
+	}
+
+	// Validate all page IDs in the order list
+	if len(pageOrder) != len(existingPages) {
+		return fmt.Errorf("page order list length mismatch: expected %d, got %d", len(existingPages), len(pageOrder))
+	}
+
+	for _, pageID := range pageOrder {
+		if _, exists := pageMap[pageID]; !exists {
+			return fmt.Errorf("page %s not found or does not belong to user", pageID)
+		}
+	}
+
+	// Update each page's order
+	now := time.Now()
+	for i, pageID := range pageOrder {
+		input := &dynamodb.UpdateItemInput{
+			TableName: aws.String("Pages"),
+			Key: map[string]types.AttributeValue{
+				"user_id": &types.AttributeValueMemberS{Value: userID},
+				"page_id": &types.AttributeValueMemberS{Value: pageID},
+			},
+			UpdateExpression: aws.String("SET #order = :order, updated_at = :updated_at"),
+			ExpressionAttributeNames: map[string]string{
+				"#order": "order",
+			},
+			ExpressionAttributeValues: map[string]types.AttributeValue{
+				":order":      &types.AttributeValueMemberN{Value: fmt.Sprintf("%d", i)},
+				":updated_at": &types.AttributeValueMemberS{Value: now.Format(time.RFC3339)},
+			},
+		}
+
+		_, err = s.db.UpdateItem(ctx, input)
+		if err != nil {
+			return fmt.Errorf("failed to update page order for page %s: %w", pageID, err)
+		}
+	}
+
+	return nil
+}
+
+// sortPagesByOrder sorts pages by their order field (in-place)
+func sortPagesByOrder(pages []*models.Page) {
+	// Simple bubble sort since we expect small number of pages
+	n := len(pages)
+	for i := 0; i < n-1; i++ {
+		for j := 0; j < n-i-1; j++ {
+			if pages[j].Order > pages[j+1].Order {
+				pages[j], pages[j+1] = pages[j+1], pages[j]
+			}
+		}
+	}
+}

internal/services/page_service_test.go

@@ -0,0 +1,350 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"custom-start-page/internal/models"
+	"custom-start-page/internal/storage"
+)
+
+func setupPageServiceTest(t *testing.T) (*PageService, context.Context, func()) {
+	ctx := context.Background()
+
+	// Create DynamoDB client
+	db, err := storage.NewDynamoDBClient(ctx, "http://localhost:8000")
+	require.NoError(t, err, "Failed to create DynamoDB client")
+
+	// Create tables
+	err = db.CreatePagesTable(ctx)
+	require.NoError(t, err, "Failed to create Pages table")
+
+	err = db.CreateWidgetsTable(ctx)
+	require.NoError(t, err, "Failed to create Widgets table")
+
+	service := NewPageService(db)
+
+	cleanup := func() {
+		// Clean up test data
+		client := db.GetClient()
+		
+		// Delete Pages table
+		_, _ = client.DeleteTable(ctx, &dynamodb.DeleteTableInput{
+			TableName: aws.String("Pages"),
+		})
+		
+		// Delete Widgets table
+		_, _ = client.DeleteTable(ctx, &dynamodb.DeleteTableInput{
+			TableName: aws.String("Widgets"),
+		})
+	}
+
+	return service, ctx, cleanup
+}
+
+func TestCreateDefaultPage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-1"
+
+	page, err := service.CreateDefaultPage(ctx, userID)
+	require.NoError(t, err)
+	assert.NotEmpty(t, page.ID)
+	assert.Equal(t, userID, page.UserID)
+	assert.Equal(t, "Home", page.Name)
+	assert.Equal(t, 0, page.Order)
+	assert.False(t, page.CreatedAt.IsZero())
+	assert.False(t, page.UpdatedAt.IsZero())
+}
+
+func TestGetPages(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-2"
+
+	// Create multiple pages
+	page1, err := service.CreatePage(ctx, userID, "Home")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Work")
+	require.NoError(t, err)
+
+	page3, err := service.CreatePage(ctx, userID, "Personal")
+	require.NoError(t, err)
+
+	// Get all pages
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 3)
+
+	// Verify pages are sorted by order
+	assert.Equal(t, page1.ID, pages[0].ID)
+	assert.Equal(t, page2.ID, pages[1].ID)
+	assert.Equal(t, page3.ID, pages[2].ID)
+
+	assert.Equal(t, 0, pages[0].Order)
+	assert.Equal(t, 1, pages[1].Order)
+	assert.Equal(t, 2, pages[2].Order)
+}
+
+func TestGetPagesEmptyResult(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-nonexistent"
+
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Empty(t, pages)
+}
+
+func TestCreatePage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-3"
+
+	page, err := service.CreatePage(ctx, userID, "Test Page")
+	require.NoError(t, err)
+	assert.NotEmpty(t, page.ID)
+	assert.Equal(t, userID, page.UserID)
+	assert.Equal(t, "Test Page", page.Name)
+	assert.Equal(t, 0, page.Order)
+
+	// Create another page
+	page2, err := service.CreatePage(ctx, userID, "Second Page")
+	require.NoError(t, err)
+	assert.Equal(t, 1, page2.Order)
+}
+
+func TestUpdatePage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-4"
+
+	// Create a page
+	page, err := service.CreatePage(ctx, userID, "Original Name")
+	require.NoError(t, err)
+
+	// Update the page name
+	updatedPage, err := service.UpdatePage(ctx, userID, page.ID, "Updated Name")
+	require.NoError(t, err)
+	assert.Equal(t, page.ID, updatedPage.ID)
+	assert.Equal(t, "Updated Name", updatedPage.Name)
+	assert.True(t, updatedPage.UpdatedAt.After(page.UpdatedAt) || updatedPage.UpdatedAt.Equal(page.UpdatedAt))
+}
+
+func TestDeletePage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-5"
+
+	// Create multiple pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Delete page2
+	err = service.DeletePage(ctx, userID, page2.ID)
+	require.NoError(t, err)
+
+	// Verify only page1 remains
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 1)
+	assert.Equal(t, page1.ID, pages[0].ID)
+}
+
+func TestDeleteLastPagePrevention(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-6"
+
+	// Create a single page
+	page, err := service.CreatePage(ctx, userID, "Only Page")
+	require.NoError(t, err)
+
+	// Attempt to delete the last page
+	err = service.DeletePage(ctx, userID, page.ID)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "cannot delete the last page")
+
+	// Verify page still exists
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 1)
+}
+
+func TestDeletePageWithWidgets(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-7"
+
+	// Create two pages
+	_, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Add widgets to page2
+	db := service.db
+	for i := 0; i < 3; i++ {
+		widget := &models.Widget{
+			ID:     fmt.Sprintf("widget-%d", i),
+			PageID: page2.ID,
+			UserID: userID,
+			Type:   models.WidgetTypeBookmark,
+			Position: models.Position{X: 0, Y: i},
+			Size:     models.Size{Width: 1, Height: 1},
+			Config:   make(map[string]interface{}),
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		}
+
+		item, err := attributevalue.MarshalMap(widget)
+		require.NoError(t, err)
+
+		err = db.PutItem(ctx, &dynamodb.PutItemInput{
+			TableName: aws.String("Widgets"),
+			Item:      item,
+		})
+		require.NoError(t, err)
+	}
+
+	// Delete page2 (should cascade delete widgets)
+	err = service.DeletePage(ctx, userID, page2.ID)
+	require.NoError(t, err)
+
+	// Verify widgets are deleted
+	widgetsOutput, err := db.Query(ctx, &dynamodb.QueryInput{
+		TableName:              aws.String("Widgets"),
+		KeyConditionExpression: aws.String("page_id = :page_id"),
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":page_id": &types.AttributeValueMemberS{Value: page2.ID},
+		},
+	})
+	require.NoError(t, err)
+	assert.Empty(t, widgetsOutput.Items)
+}
+
+func TestReorderPages(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-8"
+
+	// Create three pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	page3, err := service.CreatePage(ctx, userID, "Page 3")
+	require.NoError(t, err)
+
+	// Reorder: page3, page1, page2
+	newOrder := []string{page3.ID, page1.ID, page2.ID}
+	err = service.ReorderPages(ctx, userID, newOrder)
+	require.NoError(t, err)
+
+	// Verify new order
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 3)
+
+	assert.Equal(t, page3.ID, pages[0].ID)
+	assert.Equal(t, 0, pages[0].Order)
+
+	assert.Equal(t, page1.ID, pages[1].ID)
+	assert.Equal(t, 1, pages[1].Order)
+
+	assert.Equal(t, page2.ID, pages[2].ID)
+	assert.Equal(t, 2, pages[2].Order)
+}
+
+func TestReorderPagesInvalidLength(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-9"
+
+	// Create two pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	_, err = service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Attempt to reorder with wrong number of pages
+	err = service.ReorderPages(ctx, userID, []string{page1.ID})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "page order list length mismatch")
+}
+
+func TestReorderPagesInvalidPageID(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-10"
+
+	// Create two pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	_, err = service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Attempt to reorder with invalid page ID
+	err = service.ReorderPages(ctx, userID, []string{page1.ID, "invalid-page-id"})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "not found or does not belong to user")
+}
+
+func TestReorderPagesPersistence(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-11"
+
+	// Create three pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	page3, err := service.CreatePage(ctx, userID, "Page 3")
+	require.NoError(t, err)
+
+	// Reorder
+	newOrder := []string{page2.ID, page3.ID, page1.ID}
+	err = service.ReorderPages(ctx, userID, newOrder)
+	require.NoError(t, err)
+
+	// Retrieve pages again to verify persistence
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+
+	assert.Equal(t, page2.ID, pages[0].ID)
+	assert.Equal(t, page3.ID, pages[1].ID)
+	assert.Equal(t, page1.ID, pages[2].ID)
+}

internal/services/page_service_unit_test.go

@@ -0,0 +1,73 @@
+package services
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"custom-start-page/internal/models"
+)
+
+// TestSortPagesByOrder tests the sorting function without requiring DynamoDB
+func TestSortPagesByOrder(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-3", Order: 2},
+		{ID: "page-1", Order: 0},
+		{ID: "page-2", Order: 1},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Equal(t, "page-1", pages[0].ID)
+	assert.Equal(t, "page-2", pages[1].ID)
+	assert.Equal(t, "page-3", pages[2].ID)
+}
+
+// TestSortPagesByOrderAlreadySorted tests sorting already sorted pages
+func TestSortPagesByOrderAlreadySorted(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-1", Order: 0},
+		{ID: "page-2", Order: 1},
+		{ID: "page-3", Order: 2},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Equal(t, "page-1", pages[0].ID)
+	assert.Equal(t, "page-2", pages[1].ID)
+	assert.Equal(t, "page-3", pages[2].ID)
+}
+
+// TestSortPagesByOrderReversed tests sorting reversed pages
+func TestSortPagesByOrderReversed(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-3", Order: 2},
+		{ID: "page-2", Order: 1},
+		{ID: "page-1", Order: 0},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Equal(t, "page-1", pages[0].ID)
+	assert.Equal(t, "page-2", pages[1].ID)
+	assert.Equal(t, "page-3", pages[2].ID)
+}
+
+// TestSortPagesByOrderEmpty tests sorting empty slice
+func TestSortPagesByOrderEmpty(t *testing.T) {
+	pages := []*models.Page{}
+	sortPagesByOrder(pages)
+	assert.Empty(t, pages)
+}
+
+// TestSortPagesByOrderSingle tests sorting single page
+func TestSortPagesByOrderSingle(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-1", Order: 0},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Len(t, pages, 1)
+	assert.Equal(t, "page-1", pages[0].ID)
+}