relay-flow 0.2.9-alpha → 0.2.10-alpha

package/internal/server/observability.go

@@ -0,0 +1,109 @@
+package server
+
+import (
+	"context"
+	"sort"
+
+	"github.com/rajpopat27/relay-flow/internal/run"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+// WorkflowSummary is a read-only consumer DTO for compact workflow listing.
+// The embedded definition keeps the existing JSON fields available while the
+// additive fields provide the one-request execution summary used by the CLI.
+type WorkflowSummary struct {
+	*workflow.Workflow
+	Repositories []string `json:"repositories,omitempty"`
+	NodeCount    int      `json:"nodeCount"`
+	ActiveRuns   int      `json:"activeRuns"`
+	LatestRun    *run.Run `json:"latestRun,omitempty"`
+}
+
+// WorkflowDetail is a read-only query DTO. It deliberately contains domain
+// values only; no executor, database, runner, or task-system implementation
+// type crosses the Unix-socket boundary.
+type WorkflowDetail struct {
+	*workflow.Workflow
+	Valid      bool      `json:"valid"`
+	ActiveRuns int       `json:"activeRuns"`
+	RecentRuns []run.Run `json:"recentRuns"`
+}
+
+// WorkflowSummaryQueries is an optional server capability. Keeping it
+// separate from Deps preserves the small existing service contract for test
+// fakes and older composition roots.
+type WorkflowSummaryQueries interface {
+	ListWorkflowSummaries(context.Context) ([]WorkflowSummary, error)
+}
+
+type WorkflowDetailQueries interface {
+	GetWorkflowDetail(context.Context, string) (WorkflowDetail, error)
+}
+
+type RunDetailQueries interface {
+	GetRunDetail(context.Context, string) (run.RunDetail, error)
+}
+
+// BuildWorkflowSummaries computes all summaries from one workflow list and one
+// run list. The helper is used by the composition root and is intentionally
+// independent of a durable executor implementation.
+func BuildWorkflowSummaries(workflows []*workflow.Workflow, runs []run.Run) []WorkflowSummary {
+	latest := map[string]run.Run{}
+	active := map[string]int{}
+	for _, candidate := range runs {
+		if current, ok := latest[candidate.Workflow]; !ok || newerRun(candidate, current) {
+			latest[candidate.Workflow] = candidate
+		}
+		if candidate.State != run.StateCompleted && candidate.State != run.StateCanceled {
+			active[candidate.Workflow]++
+		}
+	}
+	out := make([]WorkflowSummary, 0, len(workflows))
+	for _, wf := range workflows {
+		if wf == nil {
+			continue
+		}
+		repos := append([]string(nil), wf.Repos...)
+		sort.Strings(repos)
+		var latestRun *run.Run
+		if candidate, ok := latest[wf.Name]; ok {
+			copy := candidate
+			latestRun = &copy
+		}
+		out = append(out, WorkflowSummary{
+			Workflow: wf, Repositories: repos, NodeCount: len(wf.Nodes),
+			ActiveRuns: active[wf.Name], LatestRun: latestRun,
+		})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
+	return out
+}
+
+func newerRun(candidate, current run.Run) bool {
+	if candidate.StartedAt.After(current.StartedAt) {
+		return true
+	}
+	return candidate.StartedAt.Equal(current.StartedAt) && candidate.UpdatedAt.After(current.UpdatedAt)
+}
+
+// BuildWorkflowDetail builds the static-definition plus recent execution
+// summary response without changing workflow validation or execution.
+func BuildWorkflowDetail(wf *workflow.Workflow, runs []run.Run) WorkflowDetail {
+	recent := append([]run.Run(nil), runs...)
+	sort.SliceStable(recent, func(i, j int) bool {
+		if recent[i].UpdatedAt.Equal(recent[j].UpdatedAt) {
+			return recent[i].StartedAt.After(recent[j].StartedAt)
+		}
+		return recent[i].UpdatedAt.After(recent[j].UpdatedAt)
+	})
+	if len(recent) > 5 {
+		recent = recent[:5]
+	}
+	active := 0
+	for _, candidate := range runs {
+		if candidate.State != run.StateCompleted && candidate.State != run.StateCanceled {
+			active++
+		}
+	}
+	return WorkflowDetail{Workflow: wf, Valid: wf != nil, ActiveRuns: active, RecentRuns: recent}
+}

package/internal/server/observability_test.go

@@ -0,0 +1,60 @@
+package server
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/run"
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+func TestWorkflowSummaryKeepsDefinitionFieldsOnJSONRoundTrip(t *testing.T) {
+	definition := &workflow.Workflow{Name: "basicFlow", Repos: []string{"payments"}, Nodes: map[string]workflow.Node{"start": {}, "end": {}}}
+	summary := WorkflowSummary{Workflow: definition, Repositories: []string{"payments"}, NodeCount: 2, ActiveRuns: 1}
+	raw, err := json.Marshal(summary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var decoded WorkflowSummary
+	if err := json.Unmarshal(raw, &decoded); err != nil {
+		t.Fatal(err)
+	}
+	if decoded.Workflow == nil || decoded.Name != definition.Name || decoded.NodeCount != 2 || decoded.ActiveRuns != 1 {
+		t.Fatalf("decoded summary = %#v", decoded)
+	}
+	arrayRaw, err := json.Marshal([]WorkflowSummary{summary})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var legacy []*workflow.Workflow
+	if err := json.Unmarshal(arrayRaw, &legacy); err != nil || len(legacy) != 1 || legacy[0].Name != definition.Name {
+		t.Fatalf("legacy workflow decode = %#v, err=%v", legacy, err)
+	}
+	baseRaw, err := json.Marshal([]*workflow.Workflow{definition})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fallback []WorkflowSummary
+	if err := json.Unmarshal(baseRaw, &fallback); err != nil || len(fallback) != 1 || fallback[0].Workflow == nil || fallback[0].Name != definition.Name {
+		t.Fatalf("fallback summary decode = %#v, err=%v", fallback, err)
+	}
+}
+
+func TestBuildWorkflowSummariesUsesLatestRunAndActiveCount(t *testing.T) {
+	start := time.Now().UTC().Add(-time.Hour)
+	workflows := []*workflow.Workflow{
+		{Name: "basicFlow", Repos: []string{"payments"}, Nodes: map[string]workflow.Node{
+			"start": {}, "end": {},
+		}},
+	}
+	runs := []run.Run{
+		{Workflow: "basicFlow", State: run.StateCompleted, StartedAt: start, UpdatedAt: start.Add(10 * time.Minute), Ticket: task.TicketRef{Key: "PAY-1"}},
+		{Workflow: "basicFlow", State: run.StateWaiting, StartedAt: start.Add(time.Minute), UpdatedAt: start.Add(20 * time.Minute), Ticket: task.TicketRef{Key: "PAY-2"}},
+	}
+	got := BuildWorkflowSummaries(workflows, runs)
+	if len(got) != 1 || got[0].ActiveRuns != 1 || got[0].LatestRun == nil || got[0].LatestRun.Ticket.Key != "PAY-2" {
+		t.Fatalf("summaries = %#v", got)
+	}
+}

package/internal/server/server.go

@@ -131,6 +131,8 @@ func mapErr(w http.ResponseWriter, err error) {
 	switch {
 	case errors.Is(err, run.ErrRestartConflict):
 		writeErr(w, http.StatusConflict, "conflict", err.Error())
+	case errors.Is(err, run.ErrNotFound):
+		writeErr(w, http.StatusNotFound, "notFound", err.Error())
 	case errors.Is(err, ErrNotFound):
 		writeErr(w, http.StatusNotFound, "notFound", err.Error())
 	case errors.Is(err, ErrConflict):
@@ -191,6 +193,18 @@ func (s *server) handleStop(w http.ResponseWriter, r *http.Request) {
 func (s *server) handleWorkflows(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
+		// The summary DTO embeds the original definition, so returning it is
+		// additive for clients that still decode []workflow.Workflow. Older
+		// composition roots without this optional capability use the base list.
+		if queries, ok := s.deps.(WorkflowSummaryQueries); ok {
+			summaries, err := queries.ListWorkflowSummaries(r.Context())
+			if err != nil {
+				mapErr(w, err)
+				return
+			}
+			writeOK(w, http.StatusOK, summaries)
+			return
+		}
 		wfs, err := s.deps.ListWorkflows(r.Context())
 		if err != nil {
 			mapErr(w, err)
@@ -225,6 +239,15 @@ func (s *server) handleWorkflowByName(w http.ResponseWriter, r *http.Request) {
 	}
 	switch r.Method {
 	case http.MethodGet:
+		if queries, ok := s.deps.(WorkflowDetailQueries); ok {
+			detail, err := queries.GetWorkflowDetail(r.Context(), name)
+			if err != nil {
+				mapErr(w, err)
+				return
+			}
+			writeOK(w, http.StatusOK, detail)
+			return
+		}
 		wf, err := s.deps.GetWorkflow(r.Context(), name)
 		if err != nil {
 			mapErr(w, err)
@@ -544,6 +567,10 @@ func (s *server) handleRuns(w http.ResponseWriter, r *http.Request) {
 	filter.Repo = q.Get("repo")
 	filter.Workflow = q.Get("workflow")
 	filter.Ticket = q.Get("ticket")
+	if active := q.Get("active"); active != "" {
+		value := active == "1" || strings.EqualFold(active, "true")
+		filter.Active = &value
+	}
 	runs, err := s.deps.ListRuns(r.Context(), filter)
 	if err != nil {
 		mapErr(w, err)
@@ -562,6 +589,15 @@ func (s *server) handleRunByTicket(w http.ResponseWriter, r *http.Request) {
 		if !methodOnly(w, r, http.MethodGet) {
 			return
 		}
+		if queries, ok := s.deps.(RunDetailQueries); ok {
+			detail, err := queries.GetRunDetail(r.Context(), parts[0])
+			if err != nil {
+				mapErr(w, err)
+				return
+			}
+			writeOK(w, http.StatusOK, detail)
+			return
+		}
 		rn, err := s.deps.GetRunByTicket(r.Context(), parts[0])
 		if err != nil {
 			mapErr(w, err)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-flow",
-  "version": "0.2.9-alpha",
+  "version": "0.2.10-alpha",
   "description": "Graph-based agent workflow engine — tracker-agnostic, pluggable runners",
   "bin": {
     "relay-flow": "./bin/relay-flow.js",