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/commands/unmark_habit.go
+7 -11
View File
@@ -4,7 +4,6 @@ import (
"context"
"time"
"apocapoc-api/internal/domain/entities"
"apocapoc-api/internal/domain/repositories"
"apocapoc-api/internal/shared/errors"
)
@@ -57,22 +56,19 @@ func (h *UnmarkHabitHandler) Handle(ctx context.Context, cmd UnmarkHabitCommand)
return err
}
// Find the active entry for this date
var targetEntry *entities.HabitEntry
// Find the entry for this date
var targetEntryID string
for _, entry := range entries {
if entry.ScheduledDate.Equal(cmd.ScheduledDate) && entry.DeletedAt == nil {
targetEntry = entry
if entry.ScheduledDate.Equal(cmd.ScheduledDate) {
targetEntryID = entry.ID
break
}
}
if targetEntry == nil {
if targetEntryID == "" {
return errors.ErrNotFound
}
// Soft delete the entry
now := time.Now()
targetEntry.DeletedAt = &now
return h.entryRepo.Update(ctx, targetEntry)
// Hard delete the entry
return h.entryRepo.Delete(ctx, targetEntryID)
}
internal/application/commands/unmark_habit_test.go
+9 -46
View File
@@ -12,20 +12,20 @@ import (
type mockEntryRepoForUnmark struct {
mockEntryRepo
entries []*entities.HabitEntry
updatedEntry *entities.HabitEntry
errorOnUpdate error
entries []*entities.HabitEntry
deletedEntryID string
errorOnDelete error
}
func (m *mockEntryRepoForUnmark) FindByHabitIDAndDateRange(ctx context.Context, habitID string, from, to time.Time) ([]*entities.HabitEntry, error) {
return m.entries, nil
}
func (m *mockEntryRepoForUnmark) Update(ctx context.Context, entry *entities.HabitEntry) error {
if m.errorOnUpdate != nil {
return m.errorOnUpdate
func (m *mockEntryRepoForUnmark) Delete(ctx context.Context, id string) error {
if m.errorOnDelete != nil {
return m.errorOnDelete
}
m.updatedEntry = entry
m.deletedEntryID = id
return nil
}
@@ -59,12 +59,8 @@ func TestUnmarkHabitHandler_UnmarksSuccessfully(t *testing.T) {
t.Fatalf("Expected no error, got %v", err)
}
if entryRepo.updatedEntry == nil {
t.Fatal("Expected entry to be updated")
}
if entryRepo.updatedEntry.DeletedAt == nil {
t.Error("Expected entry to be soft deleted")
if entryRepo.deletedEntryID != "entry-1" {
t.Errorf("Expected entry entry-1 to be deleted, got %s", entryRepo.deletedEntryID)
}
}
@@ -143,36 +139,3 @@ func TestUnmarkHabitHandler_ReturnsErrorWhenEntryNotFound(t *testing.T) {
}
}
func TestUnmarkHabitHandler_IgnoresAlreadyDeletedEntry(t *testing.T) {
habit := entities.NewHabit("user-123", "Exercise", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false)
habit.ID = "habit-1"
scheduledDate := time.Date(2025, 1, 15, 0, 0, 0, 0, time.UTC)
entry := entities.NewHabitEntry("habit-1", scheduledDate, nil)
entry.ID = "entry-1"
now := time.Now()
entry.DeletedAt = &now // Already deleted
habitRepo := &mockHabitRepoForUpdate{
habitToReturn: habit,
}
entryRepo := &mockEntryRepoForUnmark{
entries: []*entities.HabitEntry{entry},
}
handler := NewUnmarkHabitHandler(habitRepo, entryRepo)
cmd := UnmarkHabitCommand{
HabitID: "habit-1",
UserID: "user-123",
ScheduledDate: scheduledDate,
}
err := handler.Handle(context.Background(), cmd)
// Should return not found since the active entry doesn't exist
if err != errors.ErrNotFound {
t.Errorf("Expected ErrNotFound for already deleted entry, got %v", err)
}
}
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
}