Add some tie-breakers

Author: christeredvartsen

internal/persistence/sqlinstance/sortfilter.go

@@ -5,20 +5,30 @@ import (
 	"strings"
 
 	"github.com/nais/api/internal/cost"
+	"github.com/nais/api/internal/graph/model"
 	"github.com/nais/api/internal/graph/sortfilter"
+	"k8s.io/utils/ptr"
 )
 
 var (
 	SortFilterSQLInstance     = sortfilter.New[*SQLInstance, SQLInstanceOrderField, struct{}]()
 	SortFilterSQLInstanceUser = sortfilter.New[*SQLInstanceUser, SQLInstanceUserOrderField, struct{}]()
 )
 
+type SortFilterTieBreaker = sortfilter.TieBreaker[SQLInstanceOrderField]
+
 func init() {
 	SortFilterSQLInstance.RegisterSort("NAME", func(ctx context.Context, a, b *SQLInstance) int {
 		return strings.Compare(a.GetName(), b.GetName())
+	}, SortFilterTieBreaker{
+		Field:     "ENVIRONMENT",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 	SortFilterSQLInstance.RegisterSort("ENVIRONMENT", func(ctx context.Context, a, b *SQLInstance) int {
 		return strings.Compare(a.EnvironmentName, b.EnvironmentName)
+	}, SortFilterTieBreaker{
+		Field:     "NAME",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 	SortFilterSQLInstance.RegisterSort("VERSION", func(ctx context.Context, a, b *SQLInstance) int {
 		if a.Version == nil && b.Version == nil {
@@ -29,6 +39,12 @@ func init() {
 			return -1
 		}
 		return strings.Compare(*a.Version, *b.Version)
+	}, SortFilterTieBreaker{
+		Field:     "NAME",
+		Direction: ptr.To(model.OrderDirectionAsc),
+	}, SortFilterTieBreaker{
+		Field:     "ENVIRONMENT",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 	SortFilterSQLInstance.RegisterConcurrentSort("STATUS", func(ctx context.Context, a *SQLInstance) int {
 		stateOrder := map[string]int{

internal/workload/application/sortfilter.go

@@ -5,17 +5,27 @@ import (
 	"slices"
 	"strings"
 
+	"github.com/nais/api/internal/graph/model"
 	"github.com/nais/api/internal/graph/sortfilter"
+	"k8s.io/utils/ptr"
 )
 
 var SortFilter = sortfilter.New[*Application, ApplicationOrderField, *TeamApplicationsFilter]()
 
+type SortFilterTieBreaker = sortfilter.TieBreaker[ApplicationOrderField]
+
 func init() {
 	SortFilter.RegisterSort("NAME", func(ctx context.Context, a, b *Application) int {
 		return strings.Compare(a.GetName(), b.GetName())
+	}, SortFilterTieBreaker{
+		Field:     "ENVIRONMENT",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 	SortFilter.RegisterSort("ENVIRONMENT", func(ctx context.Context, a, b *Application) int {
 		return strings.Compare(a.GetEnvironmentName(), b.GetEnvironmentName())
+	}, SortFilterTieBreaker{
+		Field:     "NAME",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 
 	SortFilter.RegisterFilter(func(ctx context.Context, v *Application, filter *TeamApplicationsFilter) bool {

internal/workload/job/sortfilter.go

@@ -5,18 +5,29 @@ import (
 	"slices"
 	"strings"
 
+	"github.com/nais/api/internal/graph/model"
 	"github.com/nais/api/internal/graph/sortfilter"
+	"k8s.io/utils/ptr"
 )
 
 var SortFilter = sortfilter.New[*Job, JobOrderField, *TeamJobsFilter]()
 
+type SortFilterTieBreaker = sortfilter.TieBreaker[JobOrderField]
+
 func init() {
 	SortFilter.RegisterSort("NAME", func(ctx context.Context, a, b *Job) int {
 		return strings.Compare(a.GetName(), b.GetName())
+	}, SortFilterTieBreaker{
+		Field:     "ENVIRONMENT",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 	SortFilter.RegisterSort("ENVIRONMENT", func(ctx context.Context, a, b *Job) int {
 		return strings.Compare(a.GetEnvironmentName(), b.GetEnvironmentName())
+	}, SortFilterTieBreaker{
+		Field:     "NAME",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
+
 	SortFilter.RegisterFilter(func(ctx context.Context, v *Job, filter *TeamJobsFilter) bool {
 		if filter.Name != "" {
 			if !strings.Contains(strings.ToLower(v.Name), strings.ToLower(filter.Name)) {

internal/workload/sortfilter.go

@@ -15,14 +15,23 @@ var (
 	SortFilterEnvironment = sortfilter.New[Workload, EnvironmentWorkloadOrderField, struct{}]()
 )
 
-type SortFilterEnvironmentTieBreaker = sortfilter.TieBreaker[EnvironmentWorkloadOrderField]
+type (
+	SortFilterTieBreaker            = sortfilter.TieBreaker[WorkloadOrderField]
+	SortFilterEnvironmentTieBreaker = sortfilter.TieBreaker[EnvironmentWorkloadOrderField]
+)
 
 func init() {
 	SortFilter.RegisterSort("NAME", func(ctx context.Context, a, b Workload) int {
 		return strings.Compare(a.GetName(), b.GetName())
+	}, SortFilterTieBreaker{
+		Field:     "ENVIRONMENT",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 	SortFilter.RegisterSort("ENVIRONMENT", func(ctx context.Context, a, b Workload) int {
 		return strings.Compare(a.GetEnvironmentName(), b.GetEnvironmentName())
+	}, SortFilterTieBreaker{
+		Field:     "NAME",
+		Direction: ptr.To(model.OrderDirectionAsc),
 	})
 
 	SortFilter.RegisterFilter(func(ctx context.Context, v Workload, filter *TeamWorkloadsFilter) bool {
@@ -41,7 +50,6 @@ func init() {
 		func(ctx context.Context, a, b Workload) int {
 			return strings.Compare(a.GetName(), b.GetName())
 		},
-		// Sort by team when we have workloads with the same name
 		SortFilterEnvironmentTieBreaker{
 			Field:     "TEAM_SLUG",
 			Direction: ptr.To(model.OrderDirectionAsc),