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.go
+65 -10
View File
@@ -4,6 +4,7 @@ import (
"context"
"time"
"apocapoc-api/internal/domain/entities"
"apocapoc-api/internal/domain/repositories"
"apocapoc-api/internal/shared/errors"
)
@@ -19,6 +20,17 @@ type HabitEntryDTO struct {
type GetHabitEntriesQuery struct {
HabitID string
UserID string
From *time.Time
To *time.Time
Page int
Limit int
}
type GetHabitEntriesResult struct {
Entries []HabitEntryDTO
Total int
Page int
Limit int
}
type GetHabitEntriesHandler struct {
@@ -36,8 +48,7 @@ func NewGetHabitEntriesHandler(
}
}
func (h *GetHabitEntriesHandler) Handle(ctx context.Context, query GetHabitEntriesQuery) ([]HabitEntryDTO, error) {
// Verify habit exists and user owns it
func (h *GetHabitEntriesHandler) Handle(ctx context.Context, query GetHabitEntriesQuery) (*GetHabitEntriesResult, error) {
habit, err := h.habitRepo.FindByID(ctx, query.HabitID)
if err != nil {
return nil, err
@@ -47,19 +58,58 @@ func (h *GetHabitEntriesHandler) Handle(ctx context.Context, query GetHabitEntri
return nil, errors.ErrUnauthorized
}
// Get all entries for the habit
entries, err := h.entryRepo.FindByHabitID(ctx, query.HabitID)
var dateRangeDays int
if query.From != nil && query.To != nil {
dateRangeDays = int(query.To.Sub(*query.From).Hours() / 24)
}
requiresPagination := false
if query.From == nil || query.To == nil {
requiresPagination = true
} else if dateRangeDays > 365 {
requiresPagination = true
}
if requiresPagination && query.Limit == 0 {
return nil, errors.ErrInvalidInput
}
var entries []*entities.HabitEntry
if query.From != nil && query.To != nil {
entries, err = h.entryRepo.FindByHabitIDAndDateRange(ctx, query.HabitID, *query.From, *query.To)
} else if query.From != nil {
entries, err = h.entryRepo.FindByHabitIDAndDateRange(ctx, query.HabitID, *query.From, time.Now())
} else if query.To != nil {
entries, err = h.entryRepo.FindByHabitIDAndDateRange(ctx, query.HabitID, time.Time{}, *query.To)
} else {
entries, err = h.entryRepo.FindByHabitID(ctx, query.HabitID)
}
if err != nil {
return nil, err
}
total := len(entries)
if query.Limit > 0 {
offset := (query.Page - 1) * query.Limit
if offset < 0 {
offset = 0
}
end := offset + query.Limit
if offset < len(entries) {
if end > len(entries) {
end = len(entries)
}
entries = entries[offset:end]
} else {
entries = []*entities.HabitEntry{}
}
}
var result []HabitEntryDTO
for _, entry := range entries {
// Filter out deleted entries
if entry.DeletedAt != nil {
continue
}
result = append(result, HabitEntryDTO{
ID: entry.ID,
HabitID: entry.HabitID,
@@ -69,5 +119,10 @@ func (h *GetHabitEntriesHandler) Handle(ctx context.Context, query GetHabitEntri
})
}
return result, nil
return &GetHabitEntriesResult{
Entries: result,
Total: total,
Page: query.Page,
Limit: query.Limit,
}, nil
}
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)
}
}
internal/application/queries/get_todays_habits.go
+1 -1
View File
@@ -70,7 +70,7 @@ func (h *GetTodaysHabitsHandler) Handle(
isCompleted := false
for _, entry := range entries {
if entry.ScheduledDate.Equal(query.Date) && entry.DeletedAt == nil {
if entry.ScheduledDate.Equal(query.Date) {
isCompleted = true
break
}