feat: add crud and history manager #14

- Added generic CRUD foundation to avoid code duplication across managers
- Implemented History Manager with pagination to track HTTP request executions for debugging

Author: maniac-en

db/migrations/005_create_history_table.sql

@@ -0,0 +1,28 @@
+-- +goose Up
+CREATE TABLE history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    collection_id INTEGER,
+    collection_name TEXT,
+    endpoint_name TEXT,
+    method TEXT NOT NULL,
+    url TEXT NOT NULL,
+    status_code INTEGER NOT NULL,
+    duration INTEGER NOT NULL, -- duration in milliseconds
+    response_size INTEGER DEFAULT 0,
+    request_headers TEXT DEFAULT '{}',
+    query_params TEXT DEFAULT '{}',
+    request_body TEXT DEFAULT '',
+    response_body TEXT DEFAULT '',
+    response_headers TEXT DEFAULT '{}',
+    executed_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_history_collection_id ON history(collection_id);
+CREATE INDEX idx_history_executed_at ON history(executed_at);
+CREATE INDEX idx_history_status_code ON history(status_code);
+
+-- +goose Down
+DROP INDEX IF EXISTS idx_history_status_code;
+DROP INDEX IF EXISTS idx_history_executed_at;
+DROP INDEX IF EXISTS idx_history_collection_id;
+DROP TABLE IF EXISTS history;

db/queries/history.sql

@@ -0,0 +1,30 @@
+-- name: CreateHistoryEntry :one
+INSERT INTO history (
+    collection_id, collection_name, endpoint_name,
+    method, url, status_code, duration, response_size,
+    request_headers, query_params, request_body,
+    response_body, response_headers, executed_at
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+RETURNING *;
+
+-- name: GetHistoryById :one
+SELECT * FROM history
+WHERE id = ?;
+
+-- name: GetHistoryByCollection :many
+SELECT id, endpoint_name, status_code, executed_at, url, method FROM history
+WHERE collection_id = ?
+ORDER BY executed_at DESC
+LIMIT ? OFFSET ?;
+
+-- name: CountHistoryByCollection :one
+SELECT COUNT(*) FROM history
+WHERE collection_id = ?;
+
+-- name: DeleteHistoryEntry :exec
+DELETE FROM history
+WHERE id = ?;
+
+-- name: DeleteOldHistory :exec
+DELETE FROM history
+WHERE executed_at < datetime('now', '-30 days');

internal/crud/interfaces.go

@@ -0,0 +1,28 @@
+// Package crud provides generic CRUD operations for entities.
+package crud
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+var (
+	ErrNotFound     = errors.New("entity not found")
+	ErrInvalidInput = errors.New("invalid input")
+)
+
+type Entity interface {
+	GetID() int64
+	GetName() string
+	GetCreatedAt() time.Time
+	GetUpdatedAt() time.Time
+}
+
+type Manager[T Entity] interface {
+	Create(ctx context.Context, name string) (T, error)
+	Read(ctx context.Context, id int64) (T, error)
+	Update(ctx context.Context, id int64, name string) (T, error)
+	Delete(ctx context.Context, id int64) error
+	List(ctx context.Context) ([]T, error)
+}

internal/crud/interfaces_test.go

@@ -0,0 +1,271 @@
+package crud
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+type TestEntity struct {
+	ID        int64     `json:"id"`
+	Name      string    `json:"name"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+func (e TestEntity) GetID() int64 {
+	return e.ID
+}
+
+func (e TestEntity) GetName() string {
+	return e.Name
+}
+
+func (e TestEntity) GetCreatedAt() time.Time {
+	return e.CreatedAt
+}
+
+func (e TestEntity) GetUpdatedAt() time.Time {
+	return e.UpdatedAt
+}
+
+func TestCRUDInterface(t *testing.T) {
+	ctx := context.Background()
+	
+	t.Run("Create", func(t *testing.T) {
+		manager := &testCRUDManager{}
+		
+		entity, err := manager.Create(ctx, "test-entity")
+		if err != nil {
+			t.Fatalf("Create failed: %v", err)
+		}
+		
+		if entity.GetName() != "test-entity" {
+			t.Errorf("expected name 'test-entity', got %s", entity.GetName())
+		}
+		
+		if entity.GetID() == 0 {
+			t.Error("expected ID to be set")
+		}
+		
+		if entity.GetCreatedAt().IsZero() {
+			t.Error("expected CreatedAt to be set")
+		}
+	})
+	
+	t.Run("Read", func(t *testing.T) {
+		manager := &testCRUDManager{}
+		
+		// Create entity first
+		created, err := manager.Create(ctx, "test-read")
+		if err != nil {
+			t.Fatalf("Create failed: %v", err)
+		}
+		
+		// Read it back
+		entity, err := manager.Read(ctx, created.GetID())
+		if err != nil {
+			t.Fatalf("Read failed: %v", err)
+		}
+		
+		if entity.GetID() != created.GetID() {
+			t.Errorf("expected ID %d, got %d", created.GetID(), entity.GetID())
+		}
+		
+		if entity.GetName() != "test-read" {
+			t.Errorf("expected name 'test-read', got %s", entity.GetName())
+		}
+	})
+	
+	t.Run("Update", func(t *testing.T) {
+		manager := &testCRUDManager{}
+		
+		// Create entity first
+		created, err := manager.Create(ctx, "original-name")
+		if err != nil {
+			t.Fatalf("Create failed: %v", err)
+		}
+		
+		// Update it
+		updated, err := manager.Update(ctx, created.GetID(), "updated-name")
+		if err != nil {
+			t.Fatalf("Update failed: %v", err)
+		}
+		
+		if updated.GetName() != "updated-name" {
+			t.Errorf("expected name 'updated-name', got %s", updated.GetName())
+		}
+		
+		if updated.GetUpdatedAt().Before(created.GetUpdatedAt()) {
+			t.Error("expected UpdatedAt to be updated")
+		}
+	})
+	
+	t.Run("Delete", func(t *testing.T) {
+		manager := &testCRUDManager{}
+		
+		// Create entity first
+		created, err := manager.Create(ctx, "to-delete")
+		if err != nil {
+			t.Fatalf("Create failed: %v", err)
+		}
+		
+		// Delete it
+		err = manager.Delete(ctx, created.GetID())
+		if err != nil {
+			t.Fatalf("Delete failed: %v", err)
+		}
+		
+		// Verify it's gone
+		_, err = manager.Read(ctx, created.GetID())
+		if err == nil {
+			t.Error("expected Read to fail after Delete")
+		}
+	})
+	
+	t.Run("List", func(t *testing.T) {
+		manager := &testCRUDManager{}
+		
+		// Create some entities
+		names := []string{"entity1", "entity2", "entity3"}
+		for _, name := range names {
+			_, err := manager.Create(ctx, name)
+			if err != nil {
+				t.Fatalf("Create failed: %v", err)
+			}
+		}
+		
+		// List them
+		entities, err := manager.List(ctx)
+		if err != nil {
+			t.Fatalf("List failed: %v", err)
+		}
+		
+		if len(entities) < len(names) {
+			t.Errorf("expected at least %d entities, got %d", len(names), len(entities))
+		}
+	})
+}
+
+func TestCRUDValidation(t *testing.T) {
+	ctx := context.Background()
+	manager := &testCRUDManager{}
+	
+	t.Run("Create with empty name", func(t *testing.T) {
+		_, err := manager.Create(ctx, "")
+		if err == nil {
+			t.Error("expected Create with empty name to fail")
+		}
+	})
+	
+	t.Run("Read non-existent entity", func(t *testing.T) {
+		_, err := manager.Read(ctx, 99999)
+		if err == nil {
+			t.Error("expected Read of non-existent entity to fail")
+		}
+	})
+	
+	t.Run("Update non-existent entity", func(t *testing.T) {
+		_, err := manager.Update(ctx, 99999, "new-name")
+		if err == nil {
+			t.Error("expected Update of non-existent entity to fail")
+		}
+	})
+	
+	t.Run("Delete non-existent entity", func(t *testing.T) {
+		err := manager.Delete(ctx, 99999)
+		if err == nil {
+			t.Error("expected Delete of non-existent entity to fail")
+		}
+	})
+}
+
+type testCRUDManager struct {
+	entities map[int64]TestEntity
+	nextID   int64
+}
+
+func (m *testCRUDManager) Create(ctx context.Context, name string) (TestEntity, error) {
+	if m.entities == nil {
+		m.entities = make(map[int64]TestEntity)
+		m.nextID = 1
+	}
+	
+	if name == "" {
+		return TestEntity{}, ErrInvalidInput
+	}
+	
+	now := time.Now()
+	entity := TestEntity{
+		ID:        m.nextID,
+		Name:      name,
+		CreatedAt: now,
+		UpdatedAt: now,
+	}
+	
+	m.entities[m.nextID] = entity
+	m.nextID++
+	
+	return entity, nil
+}
+
+func (m *testCRUDManager) Read(ctx context.Context, id int64) (TestEntity, error) {
+	if m.entities == nil {
+		return TestEntity{}, ErrNotFound
+	}
+	
+	entity, exists := m.entities[id]
+	if !exists {
+		return TestEntity{}, ErrNotFound
+	}
+	
+	return entity, nil
+}
+
+func (m *testCRUDManager) Update(ctx context.Context, id int64, name string) (TestEntity, error) {
+	if m.entities == nil {
+		return TestEntity{}, ErrNotFound
+	}
+	
+	entity, exists := m.entities[id]
+	if !exists {
+		return TestEntity{}, ErrNotFound
+	}
+	
+	if name == "" {
+		return TestEntity{}, ErrInvalidInput
+	}
+	
+	entity.Name = name
+	entity.UpdatedAt = time.Now()
+	m.entities[id] = entity
+	
+	return entity, nil
+}
+
+func (m *testCRUDManager) Delete(ctx context.Context, id int64) error {
+	if m.entities == nil {
+		return ErrNotFound
+	}
+	
+	_, exists := m.entities[id]
+	if !exists {
+		return ErrNotFound
+	}
+	
+	delete(m.entities, id)
+	return nil
+}
+
+func (m *testCRUDManager) List(ctx context.Context) ([]TestEntity, error) {
+	if m.entities == nil {
+		return []TestEntity{}, nil
+	}
+	
+	entities := make([]TestEntity, 0, len(m.entities))
+	for _, entity := range m.entities {
+		entities = append(entities, entity)
+	}
+	
+	return entities, nil
+}

internal/crud/utils.go

@@ -0,0 +1,29 @@
+package crud
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/maniac-en/req/internal/log"
+)
+
+func ValidateName(name string) error {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		log.Debug("validation failed: empty name")
+		return fmt.Errorf("name cannot be empty")
+	}
+	if len(name) > 100 {
+		log.Debug("validation failed: name too long", "length", len(name))
+		return fmt.Errorf("name cannot exceed 100 characters")
+	}
+	return nil
+}
+
+func ValidateID(id int64) error {
+	if id <= 0 {
+		log.Debug("validation failed: invalid ID", "id", id)
+		return fmt.Errorf("ID must be positive")
+	}
+	return nil
+}