david/apocapoc-api
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor habit entries: remove soft delete and add smart pagination

Browse Source 
Remove soft delete from HabitEntry:
- Eliminate DeletedAt field from entity and database
- Change UnmarkHabit from soft delete to hard delete
- Simplify all queries removing deleted_at checks
- Update migration to remove deleted_at column

Add date filtering and smart pagination to GetHabitEntries:
- Support optional from/to date parameters
- Implement intelligent pagination rules:
  * No date range: pagination required
  * Date range > 1 year: pagination required
  * Date range ≤ 1 year: pagination optional
- Pagination defaults (page=1, limit=50) only when required
- Return metadata with total count, page, and limit

Technical improvements:
- Cleaner codebase without soft delete complexity
- Better performance (no filtering in queries)
- More intuitive API with flexible pagination
- Comprehensive test coverage for validation rules
This commit is contained in:
David Folch Agulles
2025-11-26 16:33:40 +01:00
parent 74cd2ec84d
commit 9f673bfca3
10 changed files with 309 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/application/queries/get_habit_entries_test.go
+145 -26
View File
@@ -2,6 +2,7 @@ package queries
import (
"context"
"strconv"
"testing"
"time"
@@ -45,24 +46,30 @@ func TestGetHabitEntriesHandler_ReturnsEntriesSuccessfully(t *testing.T) {
query := GetHabitEntriesQuery{
HabitID: "habit-1",
UserID: "user-123",
Page: 1,
Limit: 50,
}
results, err := handler.Handle(context.Background(), query)
result, err := handler.Handle(context.Background(), query)
if err != nil {
t.Fatalf("Expected no error, got %v", err)
}
if len(results) != 2 {
t.Fatalf("Expected 2 entries, got %d", len(results))
if len(result.Entries) != 2 {
t.Fatalf("Expected 2 entries, got %d", len(result.Entries))
}
if results[0].ID != "entry-1" {
t.Errorf("Expected first entry ID entry-1, got %s", results[0].ID)
if result.Entries[0].ID != "entry-1" {
t.Errorf("Expected first entry ID entry-1, got %s", result.Entries[0].ID)
}
if results[1].ID != "entry-2" {
t.Errorf("Expected second entry ID entry-2, got %s", results[1].ID)
if result.Entries[1].ID != "entry-2" {
t.Errorf("Expected second entry ID entry-2, got %s", result.Entries[1].ID)
}
if result.Total != 2 {
t.Errorf("Expected total 2, got %d", result.Total)
}
}
@@ -78,6 +85,8 @@ func TestGetHabitEntriesHandler_ReturnsErrorWhenHabitNotFound(t *testing.T) {
query := GetHabitEntriesQuery{
HabitID: "non-existent",
UserID: "user-123",
Page: 1,
Limit: 50,
}
_, err := handler.Handle(context.Background(), query)
@@ -101,7 +110,9 @@ func TestGetHabitEntriesHandler_ReturnsErrorWhenUserDoesNotOwnHabit(t *testing.T
query := GetHabitEntriesQuery{
HabitID: "habit-1",
UserID: "user-456", // Different user
UserID: "user-456",
Page: 1,
Limit: 50,
}
_, err := handler.Handle(context.Background(), query)
@@ -111,27 +122,24 @@ func TestGetHabitEntriesHandler_ReturnsErrorWhenUserDoesNotOwnHabit(t *testing.T
}
}
func TestGetHabitEntriesHandler_FiltersDeletedEntries(t *testing.T) {
func TestGetHabitEntriesHandler_WithPagination(t *testing.T) {
habit := entities.NewHabit("user-123", "Exercise", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false)
habit.ID = "habit-1"
date1 := time.Date(2025, 1, 15, 0, 0, 0, 0, time.UTC)
date2 := time.Date(2025, 1, 16, 0, 0, 0, 0, time.UTC)
entry1 := entities.NewHabitEntry("habit-1", date1, nil)
entry1.ID = "entry-1"
entry2 := entities.NewHabitEntry("habit-1", date2, nil)
entry2.ID = "entry-2"
now := time.Now()
entry2.DeletedAt = &now // This one is deleted
entries := make([]*entities.HabitEntry, 10)
for i := 0; i < 10; i++ {
date := time.Date(2025, 1, i+1, 0, 0, 0, 0, time.UTC)
entry := entities.NewHabitEntry("habit-1", date, nil)
entry.ID = "entry-" + strconv.Itoa(i+1)
entries[i] = entry
}
habitRepo := &mockHabitRepoWithFindByID{
habitToReturn: habit,
}
entryRepo := &mockEntryRepoWithFindByHabitID{
entries: []*entities.HabitEntry{entry1, entry2},
entries: entries,
}
handler := NewGetHabitEntriesHandler(habitRepo, entryRepo)
@@ -139,20 +147,131 @@ func TestGetHabitEntriesHandler_FiltersDeletedEntries(t *testing.T) {
query := GetHabitEntriesQuery{
HabitID: "habit-1",
UserID: "user-123",
Page: 2,
Limit: 3,
}
results, err := handler.Handle(context.Background(), query)
result, err := handler.Handle(context.Background(), query)
if err != nil {
t.Fatalf("Expected no error, got %v", err)
}
// Should only return the non-deleted entry
if len(results) != 1 {
t.Fatalf("Expected 1 active entry, got %d", len(results))
if len(result.Entries) != 3 {
t.Fatalf("Expected 3 entries on page 2, got %d", len(result.Entries))
}
if results[0].ID != "entry-1" {
t.Errorf("Expected entry-1 (non-deleted), got %s", results[0].ID)
if result.Total != 10 {
t.Errorf("Expected total 10, got %d", result.Total)
}
if result.Page != 2 {
t.Errorf("Expected page 2, got %d", result.Page)
}
if result.Limit != 3 {
t.Errorf("Expected limit 3, got %d", result.Limit)
}
}
func TestGetHabitEntriesHandler_RequiresPaginationWithoutDateRange(t *testing.T) {
habit := entities.NewHabit("user-123", "Exercise", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false)
habit.ID = "habit-1"
habitRepo := &mockHabitRepoWithFindByID{
habitToReturn: habit,
}
entryRepo := &mockEntryRepoWithFindByHabitID{
entries: []*entities.HabitEntry{},
}
handler := NewGetHabitEntriesHandler(habitRepo, entryRepo)
query := GetHabitEntriesQuery{
HabitID: "habit-1",
UserID: "user-123",
Page: 0,
Limit: 0,
}
_, err := handler.Handle(context.Background(), query)
if err != errors.ErrInvalidInput {
t.Errorf("Expected ErrInvalidInput when pagination not provided without date range, got %v", err)
}
}
func TestGetHabitEntriesHandler_AllowsNoPaginationWithShortDateRange(t *testing.T) {
habit := entities.NewHabit("user-123", "Exercise", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false)
habit.ID = "habit-1"
from := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
to := time.Date(2025, 6, 30, 0, 0, 0, 0, time.UTC)
entry := entities.NewHabitEntry("habit-1", from, nil)
entry.ID = "entry-1"
habitRepo := &mockHabitRepoWithFindByID{
habitToReturn: habit,
}
entryRepo := &mockEntryRepoWithFindByHabitID{
entries: []*entities.HabitEntry{entry},
}
handler := NewGetHabitEntriesHandler(habitRepo, entryRepo)
query := GetHabitEntriesQuery{
HabitID: "habit-1",
UserID: "user-123",
From: &from,
To: &to,
Page: 0,
Limit: 0,
}
result, err := handler.Handle(context.Background(), query)
if err != nil {
t.Fatalf("Expected no error for short date range without pagination, got %v", err)
}
if len(result.Entries) != 1 {
t.Errorf("Expected 1 entry, got %d", len(result.Entries))
}
}
func TestGetHabitEntriesHandler_RequiresPaginationWithLongDateRange(t *testing.T) {
habit := entities.NewHabit("user-123", "Exercise", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false)
habit.ID = "habit-1"
from := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
to := time.Date(2025, 12, 31, 0, 0, 0, 0, time.UTC)
habitRepo := &mockHabitRepoWithFindByID{
habitToReturn: habit,
}
entryRepo := &mockEntryRepoWithFindByHabitID{
entries: []*entities.HabitEntry{},
}
handler := NewGetHabitEntriesHandler(habitRepo, entryRepo)
query := GetHabitEntriesQuery{
HabitID: "habit-1",
UserID: "user-123",
From: &from,
To: &to,
Page: 0,
Limit: 0,
}
_, err := handler.Handle(context.Background(), query)
if err != errors.ErrInvalidInput {
t.Errorf("Expected ErrInvalidInput for date range > 1 year without pagination, got %v", err)
}
}