feat: add PrependSort to models that need it

internal/domain/ennoblement.go

@@ -503,6 +503,22 @@ func (params *ListEnnoblementsParams) SetSort(sort []EnnoblementSort) error {
 	return nil
 }
 
+func (params *ListEnnoblementsParams) PrependSort(sort []EnnoblementSort) error {
+	if len(sort) == 0 {
+		return nil
+	}
+
+	if err := validateSliceLen(sort, 0, max(ennoblementSortMaxLength-len(params.sort), 0)); err != nil {
+		return ValidationError{
+			Model: listEnnoblementsParamsModelName,
+			Field: "sort",
+			Err:   err,
+		}
+	}
+
+	return params.SetSort(append(sort, params.sort...))
+}
+
 func (params *ListEnnoblementsParams) PrependSortString(sort []string, allowed []EnnoblementSort, maxLength int) error {
 	if len(sort) == 0 {
 		return nil

internal/domain/ennoblement_test.go

@@ -500,6 +500,153 @@ func TestListEnnoblementsParams_SetSort(t *testing.T) {
 	}
 }
 
+func TestListEnnoblementsParams_PrependSort(t *testing.T) {
+	t.Parallel()
+
+	defaultNewParams := func(t *testing.T) domain.ListEnnoblementsParams {
+		t.Helper()
+		return domain.ListEnnoblementsParams{}
+	}
+
+	type args struct {
+		sort []domain.EnnoblementSort
+	}
+
+	tests := []struct {
+		name        string
+		newParams   func(t *testing.T) domain.ListEnnoblementsParams
+		args        args
+		expectedErr error
+	}{
+		{
+			name: "OK",
+			args: args{
+				sort: []domain.EnnoblementSort{
+					domain.EnnoblementSortIDASC,
+					domain.EnnoblementSortServerKeyASC,
+					domain.EnnoblementSortCreatedAtASC,
+				},
+			},
+		},
+		{
+			name: "OK: custom params",
+			newParams: func(t *testing.T) domain.ListEnnoblementsParams {
+				t.Helper()
+				params := domain.NewListEnnoblementsParams()
+				require.NoError(t, params.SetSort([]domain.EnnoblementSort{
+					domain.EnnoblementSortIDASC,
+					domain.EnnoblementSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.EnnoblementSort{
+					domain.EnnoblementSortCreatedAtASC,
+				},
+			},
+		},
+		{
+			name: "OK: empty slice",
+			newParams: func(t *testing.T) domain.ListEnnoblementsParams {
+				t.Helper()
+				params := domain.NewListEnnoblementsParams()
+				require.NoError(t, params.SetSort([]domain.EnnoblementSort{
+					domain.EnnoblementSortIDASC,
+					domain.EnnoblementSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: nil,
+			},
+		},
+		{
+			name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)",
+			newParams: func(t *testing.T) domain.ListEnnoblementsParams {
+				t.Helper()
+				params := domain.NewListEnnoblementsParams()
+				require.NoError(t, params.SetSort([]domain.EnnoblementSort{
+					domain.EnnoblementSortIDASC,
+					domain.EnnoblementSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.EnnoblementSort{
+					domain.EnnoblementSortCreatedAtASC,
+					domain.EnnoblementSortCreatedAtASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListEnnoblementsParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     1,
+					Current: 2,
+				},
+			},
+		},
+		{
+			name:      "ERR: len(sort) > 3",
+			newParams: defaultNewParams,
+			args: args{
+				sort: []domain.EnnoblementSort{
+					domain.EnnoblementSortCreatedAtASC,
+					domain.EnnoblementSortCreatedAtASC,
+					domain.EnnoblementSortCreatedAtASC,
+					domain.EnnoblementSortCreatedAtASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListEnnoblementsParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     3,
+					Current: 4,
+				},
+			},
+		},
+		{
+			name: "ERR: conflict",
+			args: args{
+				sort: []domain.EnnoblementSort{
+					domain.EnnoblementSortCreatedAtASC,
+					domain.EnnoblementSortCreatedAtDESC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListEnnoblementsParams",
+				Field: "sort",
+				Err: domain.SortConflictError{
+					Sort: [2]string{domain.EnnoblementSortCreatedAtASC.String(), domain.EnnoblementSortCreatedAtDESC.String()},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			newParams := defaultNewParams
+			if tt.newParams != nil {
+				newParams = tt.newParams
+			}
+			params := newParams(t)
+
+			expectedSort := params.Sort()
+
+			require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort())
+		})
+	}
+}
+
 func TestListEnnoblementsParams_PrependSortString(t *testing.T) {
 	t.Parallel()
 

internal/domain/player_snapshot.go

@@ -449,6 +449,22 @@ func (params *ListPlayerSnapshotsParams) SetSort(sort []PlayerSnapshotSort) erro
 	return nil
 }
 
+func (params *ListPlayerSnapshotsParams) PrependSort(sort []PlayerSnapshotSort) error {
+	if len(sort) == 0 {
+		return nil
+	}
+
+	if err := validateSliceLen(sort, 0, max(playerSnapshotSortMaxLength-len(params.sort), 0)); err != nil {
+		return ValidationError{
+			Model: listPlayerSnapshotsParamsModelName,
+			Field: "sort",
+			Err:   err,
+		}
+	}
+
+	return params.SetSort(append(sort, params.sort...))
+}
+
 func (params *ListPlayerSnapshotsParams) PrependSortString(
 	sort []string,
 	allowed []PlayerSnapshotSort,

internal/domain/player_snapshot_test.go

@@ -385,6 +385,153 @@ func TestListPlayerSnapshotsParams_SetSort(t *testing.T) {
 	}
 }
 
+func TestListPlayerSnapshotsParams_PrependSort(t *testing.T) {
+	t.Parallel()
+
+	defaultNewParams := func(t *testing.T) domain.ListPlayerSnapshotsParams {
+		t.Helper()
+		return domain.ListPlayerSnapshotsParams{}
+	}
+
+	type args struct {
+		sort []domain.PlayerSnapshotSort
+	}
+
+	tests := []struct {
+		name        string
+		newParams   func(t *testing.T) domain.ListPlayerSnapshotsParams
+		args        args
+		expectedErr error
+	}{
+		{
+			name: "OK",
+			args: args{
+				sort: []domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortIDASC,
+					domain.PlayerSnapshotSortServerKeyASC,
+					domain.PlayerSnapshotSortDateASC,
+				},
+			},
+		},
+		{
+			name: "OK: custom params",
+			newParams: func(t *testing.T) domain.ListPlayerSnapshotsParams {
+				t.Helper()
+				params := domain.NewListPlayerSnapshotsParams()
+				require.NoError(t, params.SetSort([]domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortIDASC,
+					domain.PlayerSnapshotSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortDateASC,
+				},
+			},
+		},
+		{
+			name: "OK: empty slice",
+			newParams: func(t *testing.T) domain.ListPlayerSnapshotsParams {
+				t.Helper()
+				params := domain.NewListPlayerSnapshotsParams()
+				require.NoError(t, params.SetSort([]domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortIDASC,
+					domain.PlayerSnapshotSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: nil,
+			},
+		},
+		{
+			name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)",
+			newParams: func(t *testing.T) domain.ListPlayerSnapshotsParams {
+				t.Helper()
+				params := domain.NewListPlayerSnapshotsParams()
+				require.NoError(t, params.SetSort([]domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortIDASC,
+					domain.PlayerSnapshotSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortDateASC,
+					domain.PlayerSnapshotSortDateASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListPlayerSnapshotsParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     1,
+					Current: 2,
+				},
+			},
+		},
+		{
+			name:      "ERR: len(sort) > 3",
+			newParams: defaultNewParams,
+			args: args{
+				sort: []domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortDateASC,
+					domain.PlayerSnapshotSortDateASC,
+					domain.PlayerSnapshotSortDateASC,
+					domain.PlayerSnapshotSortDateASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListPlayerSnapshotsParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     3,
+					Current: 4,
+				},
+			},
+		},
+		{
+			name: "ERR: conflict",
+			args: args{
+				sort: []domain.PlayerSnapshotSort{
+					domain.PlayerSnapshotSortDateASC,
+					domain.PlayerSnapshotSortDateDESC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListPlayerSnapshotsParams",
+				Field: "sort",
+				Err: domain.SortConflictError{
+					Sort: [2]string{domain.PlayerSnapshotSortDateASC.String(), domain.PlayerSnapshotSortDateDESC.String()},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			newParams := defaultNewParams
+			if tt.newParams != nil {
+				newParams = tt.newParams
+			}
+			params := newParams(t)
+
+			expectedSort := params.Sort()
+
+			require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort())
+		})
+	}
+}
+
 func TestListPlayerSnapshotsParams_PrependSortString(t *testing.T) {
 	t.Parallel()
 

internal/domain/tribe_change.go

@@ -555,6 +555,22 @@ func (params *ListTribeChangesParams) SetLimit(limit int) error {
 	return nil
 }
 
+func (params *ListTribeChangesParams) PrependSort(sort []TribeChangeSort) error {
+	if len(sort) == 0 {
+		return nil
+	}
+
+	if err := validateSliceLen(sort, 0, max(tribeChangeSortMaxLength-len(params.sort), 0)); err != nil {
+		return ValidationError{
+			Model: listTribeChangesParamsModelName,
+			Field: "sort",
+			Err:   err,
+		}
+	}
+
+	return params.SetSort(append(sort, params.sort...))
+}
+
 func (params *ListTribeChangesParams) PrependSortString(
 	sort []string,
 	allowed []TribeChangeSort,

internal/domain/tribe_change_test.go

@@ -616,6 +616,153 @@ func TestListTribeChangesParams_SetSort(t *testing.T) {
 	}
 }
 
+func TestListTribeChangesParams_PrependSort(t *testing.T) {
+	t.Parallel()
+
+	defaultNewParams := func(t *testing.T) domain.ListTribeChangesParams {
+		t.Helper()
+		return domain.ListTribeChangesParams{}
+	}
+
+	type args struct {
+		sort []domain.TribeChangeSort
+	}
+
+	tests := []struct {
+		name        string
+		newParams   func(t *testing.T) domain.ListTribeChangesParams
+		args        args
+		expectedErr error
+	}{
+		{
+			name: "OK",
+			args: args{
+				sort: []domain.TribeChangeSort{
+					domain.TribeChangeSortIDASC,
+					domain.TribeChangeSortServerKeyASC,
+					domain.TribeChangeSortCreatedAtASC,
+				},
+			},
+		},
+		{
+			name: "OK: custom params",
+			newParams: func(t *testing.T) domain.ListTribeChangesParams {
+				t.Helper()
+				params := domain.NewListTribeChangesParams()
+				require.NoError(t, params.SetSort([]domain.TribeChangeSort{
+					domain.TribeChangeSortIDASC,
+					domain.TribeChangeSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.TribeChangeSort{
+					domain.TribeChangeSortCreatedAtASC,
+				},
+			},
+		},
+		{
+			name: "OK: empty slice",
+			newParams: func(t *testing.T) domain.ListTribeChangesParams {
+				t.Helper()
+				params := domain.NewListTribeChangesParams()
+				require.NoError(t, params.SetSort([]domain.TribeChangeSort{
+					domain.TribeChangeSortIDASC,
+					domain.TribeChangeSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: nil,
+			},
+		},
+		{
+			name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)",
+			newParams: func(t *testing.T) domain.ListTribeChangesParams {
+				t.Helper()
+				params := domain.NewListTribeChangesParams()
+				require.NoError(t, params.SetSort([]domain.TribeChangeSort{
+					domain.TribeChangeSortIDASC,
+					domain.TribeChangeSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.TribeChangeSort{
+					domain.TribeChangeSortCreatedAtASC,
+					domain.TribeChangeSortCreatedAtASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListTribeChangesParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     1,
+					Current: 2,
+				},
+			},
+		},
+		{
+			name:      "ERR: len(sort) > 3",
+			newParams: defaultNewParams,
+			args: args{
+				sort: []domain.TribeChangeSort{
+					domain.TribeChangeSortCreatedAtASC,
+					domain.TribeChangeSortCreatedAtASC,
+					domain.TribeChangeSortCreatedAtASC,
+					domain.TribeChangeSortCreatedAtASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListTribeChangesParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     3,
+					Current: 4,
+				},
+			},
+		},
+		{
+			name: "ERR: conflict",
+			args: args{
+				sort: []domain.TribeChangeSort{
+					domain.TribeChangeSortCreatedAtASC,
+					domain.TribeChangeSortCreatedAtDESC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListTribeChangesParams",
+				Field: "sort",
+				Err: domain.SortConflictError{
+					Sort: [2]string{domain.TribeChangeSortCreatedAtASC.String(), domain.TribeChangeSortCreatedAtDESC.String()},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			newParams := defaultNewParams
+			if tt.newParams != nil {
+				newParams = tt.newParams
+			}
+			params := newParams(t)
+
+			expectedSort := params.Sort()
+
+			require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort())
+		})
+	}
+}
+
 func TestListTribeChangesParams_PrependSortString(t *testing.T) {
 	t.Parallel()
 

internal/domain/tribe_snapshot.go

@@ -469,6 +469,22 @@ func (params *ListTribeSnapshotsParams) SetSort(sort []TribeSnapshotSort) error
 	return nil
 }
 
+func (params *ListTribeSnapshotsParams) PrependSort(sort []TribeSnapshotSort) error {
+	if len(sort) == 0 {
+		return nil
+	}
+
+	if err := validateSliceLen(sort, 0, max(tribeSnapshotSortMaxLength-len(params.sort), 0)); err != nil {
+		return ValidationError{
+			Model: listTribeSnapshotsParamsModelName,
+			Field: "sort",
+			Err:   err,
+		}
+	}
+
+	return params.SetSort(append(sort, params.sort...))
+}
+
 func (params *ListTribeSnapshotsParams) PrependSortString(
 	sort []string,
 	allowed []TribeSnapshotSort,

internal/domain/tribe_snapshot_test.go

@@ -387,6 +387,153 @@ func TestListTribeSnapshotsParams_SetSort(t *testing.T) {
 	}
 }
 
+func TestListTribeSnapshotsParams_PrependSort(t *testing.T) {
+	t.Parallel()
+
+	defaultNewParams := func(t *testing.T) domain.ListTribeSnapshotsParams {
+		t.Helper()
+		return domain.ListTribeSnapshotsParams{}
+	}
+
+	type args struct {
+		sort []domain.TribeSnapshotSort
+	}
+
+	tests := []struct {
+		name        string
+		newParams   func(t *testing.T) domain.ListTribeSnapshotsParams
+		args        args
+		expectedErr error
+	}{
+		{
+			name: "OK",
+			args: args{
+				sort: []domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortIDASC,
+					domain.TribeSnapshotSortServerKeyASC,
+					domain.TribeSnapshotSortDateASC,
+				},
+			},
+		},
+		{
+			name: "OK: custom params",
+			newParams: func(t *testing.T) domain.ListTribeSnapshotsParams {
+				t.Helper()
+				params := domain.NewListTribeSnapshotsParams()
+				require.NoError(t, params.SetSort([]domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortIDASC,
+					domain.TribeSnapshotSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortDateASC,
+				},
+			},
+		},
+		{
+			name: "OK: empty slice",
+			newParams: func(t *testing.T) domain.ListTribeSnapshotsParams {
+				t.Helper()
+				params := domain.NewListTribeSnapshotsParams()
+				require.NoError(t, params.SetSort([]domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortIDASC,
+					domain.TribeSnapshotSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: nil,
+			},
+		},
+		{
+			name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)",
+			newParams: func(t *testing.T) domain.ListTribeSnapshotsParams {
+				t.Helper()
+				params := domain.NewListTribeSnapshotsParams()
+				require.NoError(t, params.SetSort([]domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortIDASC,
+					domain.TribeSnapshotSortServerKeyASC,
+				}))
+				return params
+			},
+			args: args{
+				sort: []domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortDateASC,
+					domain.TribeSnapshotSortDateASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListTribeSnapshotsParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     1,
+					Current: 2,
+				},
+			},
+		},
+		{
+			name:      "ERR: len(sort) > 3",
+			newParams: defaultNewParams,
+			args: args{
+				sort: []domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortDateASC,
+					domain.TribeSnapshotSortDateASC,
+					domain.TribeSnapshotSortDateASC,
+					domain.TribeSnapshotSortDateASC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListTribeSnapshotsParams",
+				Field: "sort",
+				Err: domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     3,
+					Current: 4,
+				},
+			},
+		},
+		{
+			name: "ERR: conflict",
+			args: args{
+				sort: []domain.TribeSnapshotSort{
+					domain.TribeSnapshotSortDateASC,
+					domain.TribeSnapshotSortDateDESC,
+				},
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ListTribeSnapshotsParams",
+				Field: "sort",
+				Err: domain.SortConflictError{
+					Sort: [2]string{domain.TribeSnapshotSortDateASC.String(), domain.TribeSnapshotSortDateDESC.String()},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			newParams := defaultNewParams
+			if tt.newParams != nil {
+				newParams = tt.newParams
+			}
+			params := newParams(t)
+
+			expectedSort := params.Sort()
+
+			require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort())
+		})
+	}
+}
+
 func TestListTribeSnapshotsParams_PrependSortString(t *testing.T) {
 	t.Parallel()
 

internal/port/handler_http_api_ennoblement.go

@@ -30,18 +30,20 @@ func (h *apiHTTPHandler) ListEnnoblements(
 		return
 	}
 
-	sort := []string{domain.EnnoblementSortCreatedAtASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiEnnoblementSortAllowedValues,
-		apiEnnoblementSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiEnnoblementSortAllowedValues,
+			apiEnnoblementSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {
@@ -113,18 +115,20 @@ func (h *apiHTTPHandler) ListPlayerEnnoblements(
 		return
 	}
 
-	sort := []string{domain.EnnoblementSortCreatedAtASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiEnnoblementSortAllowedValues,
-		apiEnnoblementSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiEnnoblementSortAllowedValues,
+			apiEnnoblementSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {
@@ -196,18 +200,20 @@ func (h *apiHTTPHandler) ListTribeEnnoblements(
 		return
 	}
 
-	sort := []string{domain.EnnoblementSortCreatedAtASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiEnnoblementSortAllowedValues,
-		apiEnnoblementSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiEnnoblementSortAllowedValues,
+			apiEnnoblementSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {
@@ -279,18 +285,20 @@ func (h *apiHTTPHandler) ListVillageEnnoblements(
 		return
 	}
 
-	sort := []string{domain.EnnoblementSortCreatedAtASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiEnnoblementSortAllowedValues,
-		apiEnnoblementSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiEnnoblementSortAllowedValues,
+			apiEnnoblementSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {

internal/port/handler_http_api_player_snapshot.go

@@ -36,18 +36,20 @@ func (h *apiHTTPHandler) ListPlayerPlayerSnapshots(
 		return
 	}
 
-	sort := []string{domain.PlayerSnapshotSortDateASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiPlayerSnapshotSortAllowedValues,
-		apiPlayerSnapshotSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListPlayerSnapshotsErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiPlayerSnapshotSortAllowedValues,
+			apiPlayerSnapshotSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListPlayerSnapshotsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.PlayerSnapshotSort{domain.PlayerSnapshotSortDateASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListPlayerSnapshotsErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {

internal/port/handler_http_api_tribe_change.go

@@ -36,18 +36,20 @@ func (h *apiHTTPHandler) ListPlayerTribeChanges(
 		return
 	}
 
-	sort := []string{domain.TribeChangeSortCreatedAtASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiTribeChangeSortAllowedValues,
-		apiTribeChangeSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiTribeChangeSortAllowedValues,
+			apiTribeChangeSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.TribeChangeSort{domain.TribeChangeSortCreatedAtASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {
@@ -119,18 +121,20 @@ func (h *apiHTTPHandler) ListTribeMemberChanges(
 		return
 	}
 
-	sort := []string{domain.TribeChangeSortCreatedAtASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiTribeChangeSortAllowedValues,
-		apiTribeChangeSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiTribeChangeSortAllowedValues,
+			apiTribeChangeSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.TribeChangeSort{domain.TribeChangeSortCreatedAtASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {

internal/port/handler_http_api_tribe_snapshot.go

@@ -36,18 +36,20 @@ func (h *apiHTTPHandler) ListTribeTribeSnapshots(
 		return
 	}
 
-	sort := []string{domain.TribeSnapshotSortDateASC.String()}
 	if params.Sort != nil {
-		sort = *params.Sort
-	}
-
-	if err := domainParams.PrependSortString(
-		sort,
-		apiTribeSnapshotSortAllowedValues,
-		apiTribeSnapshotSortMaxLength,
-	); err != nil {
-		h.errorRenderer.withErrorPathFormatter(formatListTribeSnapshotsErrorPath).render(w, r, err)
-		return
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiTribeSnapshotSortAllowedValues,
+			apiTribeSnapshotSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListTribeSnapshotsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.TribeSnapshotSort{domain.TribeSnapshotSortDateASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListTribeSnapshotsErrorPath).render(w, r, err)
+			return
+		}
 	}
 
 	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {