feat(query): add execution history and current state read queries

Author: pixel365

internal/model/result.go

@@ -1,6 +1,7 @@
 package model
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/pixel365/pulse/internal/config"
@@ -65,3 +66,61 @@ type CheckPolicy struct {
 	FailureThreshold int
 	SuccessThreshold int
 }
+
+type CheckExecutionRecord struct {
+	CreatedAt time.Time
+	ID        string
+	CheckExecutionResult
+}
+
+type CheckExecutionFilter struct {
+	From      *time.Time
+	To        *time.Time
+	ServiceID string
+	CheckID   string
+	Limit     int
+}
+
+func (f *CheckExecutionFilter) Apply(query string, fieldFn func(string) string) (string, []any) {
+	var (
+		conditions []string
+		args       []any
+	)
+
+	if f.ServiceID != "" {
+		args = append(args, f.ServiceID)
+		conditions = append(conditions, fmt.Sprintf("%s = $%d", fieldFn("service_id"), len(args)))
+	}
+
+	if f.CheckID != "" {
+		args = append(args, f.CheckID)
+		conditions = append(conditions, fmt.Sprintf("%s = $%d", fieldFn("check_id"), len(args)))
+	}
+
+	if f.From != nil {
+		args = append(args, *f.From)
+		conditions = append(conditions, fmt.Sprintf("%s >= $%d", fieldFn("finished_at"), len(args)))
+	}
+
+	if f.To != nil {
+		args = append(args, *f.To)
+		conditions = append(conditions, fmt.Sprintf("%s <= $%d", fieldFn("finished_at"), len(args)))
+	}
+
+	if len(conditions) > 0 {
+		query += "WHERE " + conditions[0]
+		for i := 1; i < len(conditions); i++ {
+			query += " AND " + conditions[i]
+		}
+		query += "\n"
+	}
+
+	query += fmt.Sprintf("ORDER BY %s DESC\n", fieldFn("finished_at"))
+
+	if f.Limit > 0 {
+		args = append(args, f.Limit)
+		query += fmt.Sprintf("LIMIT $%d\n", len(args))
+	}
+
+	return query, args
+}

internal/repository/check/execution.go

@@ -3,6 +3,7 @@ package check
 import (
 	"context"
 	"encoding/json"
+	"time"
 
 	"github.com/pixel365/pulse/internal/repository"
 
@@ -68,6 +69,102 @@ INSERT INTO pulse.check_executions (
 	return err
 }
 
+func (e *ExecutionCheck) ListExecutions(
+	ctx context.Context,
+	filter model.CheckExecutionFilter,
+) ([]model.CheckExecutionRecord, error) {
+	query := `
+SELECT 
+    execution_id,
+    check_id,
+    service_id,
+    status,
+    check_type,
+    started_at,
+    finished_at,
+    duration,
+    attempts_total,
+    error_kind,
+    error_message,
+    details,
+    created_at
+FROM pulse.check_executions
+`
+
+	query, args := filter.Apply(query, mustField)
+
+	rows, err := e.db.Query(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var result []model.CheckExecutionRecord
+
+	for rows.Next() {
+		var (
+			row             model.CheckExecutionRecord
+			details         []byte
+			rawErrorKind    *string
+			rawErrorMessage *string
+			rawDurationUs   int64
+		)
+
+		err = rows.Scan(
+			&row.ExecutionID,
+			&row.CheckID,
+			&row.ServiceID,
+			&row.Status,
+			&row.CheckType,
+			&row.StartedAt,
+			&row.FinishedAt,
+			&rawDurationUs,
+			&row.AttemptsTotal,
+			&rawErrorKind,
+			&rawErrorMessage,
+			&details,
+			&row.CreatedAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		if rawErrorKind != nil {
+			row.ErrorKind = e2.ErrorKind(*rawErrorKind)
+		}
+
+		if rawErrorMessage != nil {
+			row.ErrorMessage = *rawErrorMessage
+		}
+
+		if details != nil {
+			err = json.Unmarshal(details, &row.Details)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		row.Duration = time.Duration(rawDurationUs) * time.Microsecond
+
+		result = append(result, row)
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func mustField(name string) string {
+	switch name {
+	case "service_id", "check_id", "finished_at":
+		return name
+	}
+
+	panic("unknown field " + name + " in check execution filter")
+}
+
 func NewExecutionRepository(db repository.QueryExecutor) *ExecutionCheck {
 	return &ExecutionCheck{db}
 }

internal/repository/check/interfaces.go

@@ -14,4 +14,8 @@ type CheckStateRepository interface {
 
 type CheckExecutionRepository interface {
 	Add(context.Context, model.CheckExecutionResult) error
+	ListExecutions(
+		context.Context,
+		model.CheckExecutionFilter,
+	) ([]model.CheckExecutionRecord, error)
 }