feat: server map generator (#59)

Reviewed-on: #59

.golangci.yml

@@ -505,6 +505,9 @@ issues:
       linters:
         - gosec
         - gocyclo
+    - path: server_map.go
+      linters:
+        - mnd
     - path: _test\.go
       text: add-constant
     - path: bun/migrations

.pre-commit-config.yaml

@@ -6,7 +6,7 @@ repos:
         stages: [commit-msg]
         additional_dependencies: ["@commitlint/config-conventional"]
   - repo: https://github.com/golangci/golangci-lint
-    rev: v1.58.1
+    rev: v1.59.0
     hooks:
       - id: golangci-lint
   - repo: https://github.com/hadolint/hadolint

.woodpecker/test.yml

@@ -42,7 +42,7 @@ steps:
       - go test -parallel 2 -race -coverprofile=coverage.txt -covermode=atomic ./...
 
   lint:
-    image: golangci/golangci-lint:v1.58
+    image: golangci/golangci-lint:v1.59
     pull: true
     depends_on:
       - generate

Makefile

@@ -16,7 +16,7 @@ install-git-hooks:
 .PHONY: install-golangci-lint
 install-golangci-lint:
 	@echo "Installing github.com/golangci/golangci-lint..."
-	@(test -f $(GOLANGCI_LINT_PATH) && echo "github.com/golangci/golangci-lint is already installed. Skipping...") || curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOBIN) v1.58.1
+	@(test -f $(GOLANGCI_LINT_PATH) && echo "github.com/golangci/golangci-lint is already installed. Skipping...") || curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOBIN) v1.59.0
 
 .PHONY: install-oapi-codegen
 install-oapi-codegen:

api/openapi3.yml

@@ -471,6 +471,25 @@ paths:
           $ref: "#/components/responses/ListTribeChangesResponse"
         default:
           $ref: "#/components/responses/ErrorResponse"
+  /v2/versions/{versionCode}/servers/{serverKey}/snapshots:
+    get:
+      operationId: listServerServerSnapshots
+      tags:
+        - versions
+        - servers
+        - snapshots
+      description: List the given server's snapshots
+      parameters:
+        - $ref: "#/components/parameters/VersionCodePathParam"
+        - $ref: "#/components/parameters/ServerKeyPathParam"
+        - $ref: "#/components/parameters/CursorQueryParam"
+        - $ref: "#/components/parameters/LimitQueryParam"
+        - $ref: "#/components/parameters/ServerSnapshotSortQueryParam"
+      responses:
+        200:
+          $ref: "#/components/responses/ListServerSnapshotsResponse"
+        default:
+          $ref: "#/components/responses/ErrorResponse"
   /v2/versions/{versionCode}/servers/{serverKey}/tribes/{tribeId}/snapshots:
     get:
       operationId: listTribeTribeSnapshots
@@ -1594,6 +1613,52 @@ components:
         createdAt:
           type: string
           format: date-time
+    ServerSnapshot:
+      type: object
+      required:
+        - id
+        - server
+        - numPlayers
+        - numActivePlayers
+        - numInactivePlayers
+        - numTribes
+        - numActiveTribes
+        - numInactiveTribes
+        - numVillages
+        - numBarbarianVillages
+        - numBonusVillages
+        - numPlayerVillages
+        - date
+      properties:
+        id:
+          $ref: "#/components/schemas/IntId"
+        server:
+          $ref: "#/components/schemas/ServerMeta"
+        numPlayers:
+          type: integer
+          description: numActivePlayers+numInactivePlayers
+        numActivePlayers:
+          type: integer
+        numInactivePlayers:
+          type: integer
+        numTribes:
+          type: integer
+          description: numActiveTribes+numInactiveTribes
+        numActiveTribes:
+          type: integer
+        numInactiveTribes:
+          type: integer
+        numVillages:
+          type: integer
+        numBarbarianVillages:
+          type: integer
+        numBonusVillages:
+          type: integer
+        numPlayerVillages:
+          type: integer
+        date:
+          type: string
+          format: date
     TribeSnapshot:
       type: object
       required:
@@ -1675,7 +1740,7 @@ components:
           x-go-type-skip-optional-pointer: true
           allOf:
             - $ref: "#/components/schemas/CursorString"
-    PaginationResponse:
+    Pagination:
       type: object
       properties:
         cursor:
@@ -1729,6 +1794,8 @@ components:
             - odScoreTotal:DESC
             - points:ASC
             - points:DESC
+            - mostPoints:ASC
+            - mostPoints:DESC
             - dominance:ASC
             - dominance:DESC
             - deletedAt:ASC
@@ -1769,6 +1836,8 @@ components:
             - odScoreTotal:DESC
             - points:ASC
             - points:DESC
+            - mostPoints:ASC
+            - mostPoints:DESC
             - deletedAt:ASC
             - deletedAt:DESC
           maxItems: 2
@@ -1840,6 +1909,20 @@ components:
             - date:ASC
             - date:DESC
           maxItems: 1
+    ServerSnapshotSortQueryParam:
+      name: sort
+      in: query
+      description: Order matters!
+      schema:
+        type: array
+        default:
+          - date:ASC
+        items:
+          type: string
+          enum:
+            - date:ASC
+            - date:DESC
+          maxItems: 1
     PlayerSnapshotSortQueryParam:
       name: sort
       in: query
@@ -1905,7 +1988,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -1931,7 +2014,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -1990,7 +2073,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2016,7 +2099,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2031,7 +2114,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2057,7 +2140,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2083,7 +2166,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2098,7 +2181,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2107,13 +2190,28 @@ components:
                     type: array
                     items:
                       $ref: "#/components/schemas/TribeChange"
+    ListServerSnapshotsResponse:
+      description: ""
+      content:
+        application/json:
+          schema:
+            allOf:
+              - $ref: "#/components/schemas/Pagination"
+              - type: object
+                required:
+                  - data
+                properties:
+                  data:
+                    type: array
+                    items:
+                      $ref: "#/components/schemas/ServerSnapshot"
     ListTribeSnapshotsResponse:
       description: ""
       content:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data
@@ -2128,7 +2226,7 @@ components:
         application/json:
           schema:
             allOf:
-              - $ref: "#/components/schemas/PaginationResponse"
+              - $ref: "#/components/schemas/Pagination"
               - type: object
                 required:
                   - data

build/docker/twhelp/prod/Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=$BUILDPLATFORM alpine:3.19
+FROM alpine:3.20
 LABEL maintainer="contact@twhelp.app"
 
 ARG TARGETOS

cmd/errorcodes/main.go

@@ -1,33 +1,27 @@
 package main
 
 import (
-	"errors"
+	"fmt"
 	"go/ast"
 	"go/constant"
-	"go/importer"
-	"go/parser"
-	"go/token"
 	"go/types"
-	"io/fs"
 	"log"
 	"os"
+	"slices"
 	"strings"
 
+	"golang.org/x/tools/go/packages"
 	"gopkg.in/yaml.v3"
 )
 
 func main() {
-	if _, err := os.Stat("./go.mod"); errors.Is(err, os.ErrNotExist) {
-		log.Fatalln("go.mod not found")
-	}
-
-	if err := generateYAML("./internal/domain"); err != nil {
+	if err := generateYAML("gitea.dwysokinski.me/twhelp/core/internal/domain"); err != nil {
 		log.Fatalln(err)
 	}
 }
 
-func generateYAML(root string) error {
-	m, err := getErrorCodesFromFolder(root)
+func generateYAML(pkgPattern string) error {
+	m, err := getErrorCodesFromPackage(pkgPattern)
 	if err != nil {
 		return err
 	}
@@ -48,6 +42,8 @@ func generateYAML(root string) error {
 		enum = append(enum, c)
 	}
 
+	slices.Sort(enum)
+
 	return yaml.NewEncoder(os.Stdout).Encode(struct {
 		Type        string   `yaml:"type"`
 		Description string   `yaml:"description"`
@@ -60,27 +56,25 @@ func generateYAML(root string) error {
 }
 
 //nolint:gocyclo
-func getErrorCodesFromFolder(root string) (map[string]string, error) {
-	fset := token.NewFileSet()
-
-	astDomainPkg, err := parseDomainPackage(fset, root)
+func getErrorCodesFromPackage(pkgPattern string) (map[string]string, error) {
+	pkg, err := packages.Load(&packages.Config{
+		Tests: false,
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedTypes |
+			packages.NeedTypesInfo |
+			packages.NeedSyntax,
+	}, pkgPattern)
 	if err != nil {
 		return nil, err
 	}
-
-	conf := types.Config{Importer: importer.Default()}
-
-	files := make([]*ast.File, 0, len(astDomainPkg.Files))
-	for _, f := range astDomainPkg.Files {
-		files = append(files, f)
+	if len(pkg) == 0 {
+		return nil, fmt.Errorf("'%s': pkg not found", pkgPattern)
 	}
 
-	domainPkg, err := conf.Check(astDomainPkg.Name, fset, files, nil)
-	if err != nil {
-		return nil, err
-	}
-	scope := domainPkg.Scope()
-
+	domainPkg := pkg[0]
+	scope := domainPkg.Types.Scope()
 	m := make(map[string]string)
 
 	for _, n := range scope.Names() {
@@ -95,14 +89,21 @@ func getErrorCodesFromFolder(root string) (map[string]string, error) {
 			continue
 		}
 
-		f := astDomainPkg.Files[fset.File(c.Pos()).Name()]
-		position := fset.Position(c.Pos())
-		commentMap := ast.NewCommentMap(fset, f, f.Comments)
+		filename := domainPkg.Fset.File(c.Pos()).Name()
+		fileIdx := slices.IndexFunc(domainPkg.GoFiles, func(f string) bool {
+			return f == filename
+		})
+		if fileIdx < 0 {
+			return nil, fmt.Errorf("'%s': file not found", filename)
+		}
+		f := domainPkg.Syntax[fileIdx]
+		position := domainPkg.Fset.Position(c.Pos())
+		commentMap := ast.NewCommentMap(domainPkg.Fset, f, f.Comments)
 
 		var desc string
 
 		for _, decl := range f.Decls {
-			declPosition := fset.Position(decl.Pos())
+			declPosition := domainPkg.Fset.Position(decl.Pos())
 			if declPosition.Filename != position.Filename || declPosition.Line != position.Line {
 				continue
 			}
@@ -123,27 +124,3 @@ func getErrorCodesFromFolder(root string) (map[string]string, error) {
 
 	return m, nil
 }
-
-func parseDomainPackage(fset *token.FileSet, root string) (*ast.Package, error) {
-	pkgs, err := parser.ParseDir(fset, root, func(info fs.FileInfo) bool {
-		if info.IsDir() && info.Name() != root {
-			return false
-		}
-
-		if info.IsDir() || strings.HasSuffix(info.Name(), "_test.go") {
-			return false
-		}
-
-		return true
-	}, parser.AllErrors|parser.ParseComments)
-	if err != nil {
-		return nil, err
-	}
-
-	astDomainPkg, ok := pkgs["domain"]
-	if !ok {
-		return nil, errors.New("domain pkg not found")
-	}
-
-	return astDomainPkg, nil
-}

cmd/twhelp/cmd_serve.go

@@ -113,6 +113,7 @@ var cmdServe = &cli.Command{
 		villageRepo := adapter.NewVillageBunRepository(bunDB)
 		ennoblementRepo := adapter.NewEnnoblementBunRepository(bunDB)
 		tribeChangeRepo := adapter.NewTribeChangeBunRepository(bunDB)
+		serverSnapshotRepo := adapter.NewServerSnapshotBunRepository(bunDB)
 		tribeSnapshotRepo := adapter.NewTribeSnapshotBunRepository(bunDB)
 		playerSnapshotRepo := adapter.NewPlayerSnapshotBunRepository(bunDB)
 
@@ -124,6 +125,7 @@ var cmdServe = &cli.Command{
 		playerSvc := app.NewPlayerService(playerRepo, tribeChangeSvc, nil, nil)
 		villageSvc := app.NewVillageService(villageRepo, nil, nil)
 		ennoblementSvc := app.NewEnnoblementService(ennoblementRepo, nil, nil)
+		serverSnapshotSvc := app.NewServerSnapshotService(serverSnapshotRepo, serverSvc, nil)
 		tribeSnapshotSvc := app.NewTribeSnapshotService(tribeSnapshotRepo, tribeSvc, nil)
 		playerSnapshotSvc := app.NewPlayerSnapshotService(playerSnapshotRepo, playerSvc, nil)
 
@@ -160,6 +162,7 @@ var cmdServe = &cli.Command{
 						villageSvc,
 						ennoblementSvc,
 						tribeChangeSvc,
+						serverSnapshotSvc,
 						tribeSnapshotSvc,
 						playerSnapshotSvc,
 						port.WithOpenAPIConfig(oapiCfg),

go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/cenkalti/backoff/v4 v4.3.0
 	github.com/elliotchance/phpserialize v1.4.0
 	github.com/ettle/strcase v0.2.0
-	github.com/getkin/kin-openapi v0.124.0
+	github.com/getkin/kin-openapi v0.125.0
 	github.com/go-chi/chi/v5 v5.0.12
 	github.com/go-chi/render v1.0.3
 	github.com/google/go-cmp v0.6.0
@@ -28,7 +28,9 @@ require (
 	github.com/uptrace/bun/extra/bundebug v1.2.1
 	github.com/urfave/cli/v2 v2.27.2
 	go.uber.org/automaxprocs v1.5.3
+	golang.org/x/image v0.17.0
 	golang.org/x/sync v0.7.0
+	golang.org/x/tools v0.19.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -43,7 +45,7 @@ require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/docker/cli v20.10.17+incompatible // indirect
-	github.com/docker/docker v20.10.7+incompatible // indirect
+	github.com/docker/docker v20.10.11+incompatible // indirect
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
@@ -90,7 +92,6 @@ require (
 	golang.org/x/crypto v0.21.0 // indirect
 	golang.org/x/mod v0.16.0 // indirect
 	golang.org/x/sys v0.18.0 // indirect
-	golang.org/x/tools v0.19.0 // indirect
 	gopkg.in/yaml.v2 v2.3.0 // indirect
 	mellium.im/sasl v0.3.1 // indirect
 	modernc.org/gc/v3 v3.0.0-20240304020402-f0dba7c97c2b // indirect

go.sum

@@ -40,8 +40,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/docker/cli v20.10.17+incompatible h1:eO2KS7ZFeov5UJeaDmIs1NFEDRf32PaqRpvoEkKBy5M=
 github.com/docker/cli v20.10.17+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/docker v20.10.7+incompatible h1:Z6O9Nhsjv+ayUEeI1IojKbYcsGdgYSNqxe1s2MYzUhQ=
-github.com/docker/docker v20.10.7+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v20.10.11+incompatible h1:OqzI/g/W54LczvhnccGqniFoQghHx3pklbLuhfXpqGo=
+github.com/docker/docker v20.10.11+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
 github.com/docker/go-units v0.4.0 h1:3uh0PgVws3nIA0Q+MwDC8yjEPf9zjRfZZWXZYDct3Tw=
@@ -55,8 +55,8 @@ github.com/ettle/strcase v0.2.0/go.mod h1:DajmHElDSaX76ITe3/VHVyMin4LWSJN5Z909Wp
 github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
 github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
 github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
-github.com/getkin/kin-openapi v0.124.0 h1:VSFNMB9C9rTKBnQ/fpyDU8ytMTr4dWI9QovSKj9kz/M=
-github.com/getkin/kin-openapi v0.124.0/go.mod h1:wb1aSZA/iWmorQP9KTAS/phLj/t17B5jT7+fS8ed9NM=
+github.com/getkin/kin-openapi v0.125.0 h1:jyQCyf2qXS1qvs2U00xQzkGCqYPhEhZDmSmVt65fXno=
+github.com/getkin/kin-openapi v0.125.0/go.mod h1:wb1aSZA/iWmorQP9KTAS/phLj/t17B5jT7+fS8ed9NM=
 github.com/go-chi/chi/v5 v5.0.12 h1:9euLV5sTrTNTRUU9POmDUvfxyj6LAABLUcEWO+JJb4s=
 github.com/go-chi/chi/v5 v5.0.12/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
 github.com/go-chi/render v1.0.3 h1:AsXqd2a1/INaIfUSKq3G5uA8weYx20FOsM7uSoCyyt4=
@@ -233,6 +233,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
 golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
+golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.16.0 h1:QX4fJ0Rr5cPQCF7O9lh9Se4pmwfwskqZfq5moyldzic=

internal/adapter/repository_bun_player.go

@@ -280,6 +280,9 @@ func (a listPlayersParamsApplier) applyCursor(q *bun.SelectQuery) *bun.SelectQue
 		case domain.PlayerSortPointsASC,
 			domain.PlayerSortPointsDESC:
 			el.value = cursor.Points()
+		case domain.PlayerSortMostPointsASC,
+			domain.PlayerSortMostPointsDESC:
+			el.value = cursor.MostPoints()
 		case domain.PlayerSortDeletedAtASC,
 			domain.PlayerSortDeletedAtDESC:
 			el.value = cursor.DeletedAt()
@@ -326,6 +329,10 @@ func (a listPlayersParamsApplier) sortToColumnAndDirection(
 		return "player.points", sortDirectionASC, nil
 	case domain.PlayerSortPointsDESC:
 		return "player.points", sortDirectionDESC, nil
+	case domain.PlayerSortMostPointsASC:
+		return "player.most_points", sortDirectionASC, nil
+	case domain.PlayerSortMostPointsDESC:
+		return "player.most_points", sortDirectionDESC, nil
 	case domain.PlayerSortDeletedAtASC:
 		return "COALESCE(player.deleted_at, '0001-01-01 00:00:00+00:00')", sortDirectionASC, nil
 	case domain.PlayerSortDeletedAtDESC:

internal/adapter/repository_bun_server_snapshot.go

@@ -81,6 +81,33 @@ func (repo *ServerSnapshotBunRepository) List(
 	return domain.NewListServerSnapshotsResult(separateListResultAndNext(converted, params.Limit()))
 }
 
+func (repo *ServerSnapshotBunRepository) ListWithRelations(
+	ctx context.Context,
+	params domain.ListServerSnapshotsParams,
+) (domain.ListServerSnapshotsWithRelationsResult, error) {
+	var serverSnapshots bunmodel.ServerSnapshots
+
+	if err := repo.db.NewSelect().
+		Model(&serverSnapshots).
+		Apply(listServerSnapshotsParamsApplier{params: params}.apply).
+		Relation("Server", func(q *bun.SelectQuery) *bun.SelectQuery {
+			return q.Column(bunmodel.ServerMetaColumns...)
+		}).
+		Scan(ctx); err != nil && !errors.Is(err, sql.ErrNoRows) {
+		return domain.ListServerSnapshotsWithRelationsResult{}, fmt.Errorf(
+			"couldn't select server snapshots from the db: %w",
+			err,
+		)
+	}
+
+	converted, err := serverSnapshots.ToDomainWithRelations()
+	if err != nil {
+		return domain.ListServerSnapshotsWithRelationsResult{}, err
+	}
+
+	return domain.NewListServerSnapshotsWithRelationsResult(separateListResultAndNext(converted, params.Limit()))
+}
+
 func (repo *ServerSnapshotBunRepository) Delete(ctx context.Context, serverKey string, dateLTE time.Time) error {
 	if _, err := repo.db.NewDelete().
 		Model((*bunmodel.ServerSnapshot)(nil)).

internal/adapter/repository_bun_tribe.go

@@ -241,6 +241,9 @@ func (a listTribesParamsApplier) applyCursor(q *bun.SelectQuery) *bun.SelectQuer
 		case domain.TribeSortPointsASC,
 			domain.TribeSortPointsDESC:
 			el.value = cursor.Points()
+		case domain.TribeSortMostPointsASC,
+			domain.TribeSortMostPointsDESC:
+			el.value = cursor.MostPoints()
 		case domain.TribeSortDominanceASC,
 			domain.TribeSortDominanceDESC:
 			el.value = cursor.Dominance()
@@ -286,6 +289,10 @@ func (a listTribesParamsApplier) sortToColumnAndDirection(
 		return "tribe.points", sortDirectionASC, nil
 	case domain.TribeSortPointsDESC:
 		return "tribe.points", sortDirectionDESC, nil
+	case domain.TribeSortMostPointsASC:
+		return "tribe.most_points", sortDirectionASC, nil
+	case domain.TribeSortMostPointsDESC:
+		return "tribe.most_points", sortDirectionDESC, nil
 	case domain.TribeSortDominanceASC:
 		return "tribe.dominance", sortDirectionASC, nil
 	case domain.TribeSortDominanceDESC:

internal/adapter/repository_player_test.go

@@ -276,6 +276,56 @@ func testPlayerRepository(t *testing.T, newRepos func(t *testing.T) repositories
 					}))
 				},
 			},
+			{
+				name: "OK: sort=[mostPoints ASC, serverKey ASC, id ASC]",
+				params: func(t *testing.T) domain.ListPlayersParams {
+					t.Helper()
+					params := domain.NewListPlayersParams()
+					require.NoError(t, params.SetSort([]domain.PlayerSort{
+						domain.PlayerSortMostPointsASC,
+						domain.PlayerSortServerKeyASC,
+						domain.PlayerSortIDASC,
+					}))
+					return params
+				},
+				assertResult: func(t *testing.T, _ domain.ListPlayersParams, res domain.ListPlayersResult) {
+					t.Helper()
+					players := res.Players()
+					assert.NotEmpty(t, players)
+					assert.True(t, slices.IsSortedFunc(players, func(a, b domain.Player) int {
+						return cmp.Or(
+							cmp.Compare(a.MostPoints(), b.MostPoints()),
+							cmp.Compare(a.ServerKey(), b.ServerKey()),
+							cmp.Compare(a.ID(), b.ID()),
+						)
+					}))
+				},
+			},
+			{
+				name: "OK: sort=[mostPoints DESC, serverKey ASC, id ASC]",
+				params: func(t *testing.T) domain.ListPlayersParams {
+					t.Helper()
+					params := domain.NewListPlayersParams()
+					require.NoError(t, params.SetSort([]domain.PlayerSort{
+						domain.PlayerSortMostPointsDESC,
+						domain.PlayerSortServerKeyASC,
+						domain.PlayerSortIDASC,
+					}))
+					return params
+				},
+				assertResult: func(t *testing.T, _ domain.ListPlayersParams, res domain.ListPlayersResult) {
+					t.Helper()
+					players := res.Players()
+					assert.NotEmpty(t, players)
+					assert.True(t, slices.IsSortedFunc(players, func(a, b domain.Player) int {
+						return cmp.Or(
+							cmp.Compare(a.MostPoints(), b.MostPoints())*-1,
+							cmp.Compare(a.ServerKey(), b.ServerKey()),
+							cmp.Compare(a.ID(), b.ID()),
+						)
+					}))
+				},
+			},
 			{
 				name: "OK: sort=[deletedAt ASC, serverKey ASC, id ASC]",
 				params: func(t *testing.T) domain.ListPlayersParams {

internal/adapter/repository_server_snapshot_test.go

@@ -115,7 +115,7 @@ func testServerSnapshotRepository(t *testing.T, newRepos func(t *testing.T) repo
 		})
 	})
 
-	t.Run("List", func(t *testing.T) {
+	t.Run("List & ListWithRelations", func(t *testing.T) {
 		t.Parallel()
 
 		repos := newRepos(t)
@@ -405,6 +405,14 @@ func testServerSnapshotRepository(t *testing.T, newRepos func(t *testing.T) repo
 				res, err := repos.serverSnapshot.List(ctx, params)
 				assertError(t, err)
 				tt.assertResult(t, params, res)
+
+				resWithRelations, err := repos.serverSnapshot.ListWithRelations(ctx, params)
+				assertError(t, err)
+				require.Len(t, resWithRelations.ServerSnapshots(), len(res.ServerSnapshots()))
+				for i, ss := range resWithRelations.ServerSnapshots() {
+					assert.Equal(t, res.ServerSnapshots()[i], ss.ServerSnapshot())
+					assert.Equal(t, ss.ServerSnapshot().ServerKey(), ss.Server().Key())
+				}
 			})
 		}
 	})

internal/adapter/repository_test.go

@@ -70,6 +70,10 @@ type tribeChangeRepository interface {
 type serverSnapshotRepository interface {
 	Create(ctx context.Context, params ...domain.CreateServerSnapshotParams) error
 	List(ctx context.Context, params domain.ListServerSnapshotsParams) (domain.ListServerSnapshotsResult, error)
+	ListWithRelations(
+		ctx context.Context,
+		params domain.ListServerSnapshotsParams,
+	) (domain.ListServerSnapshotsWithRelationsResult, error)
 	Delete(ctx context.Context, serverKey string, dateLTE time.Time) error
 }
 

internal/adapter/repository_tribe_test.go

@@ -339,6 +339,56 @@ func testTribeRepository(t *testing.T, newRepos func(t *testing.T) repositories)
 					}))
 				},
 			},
+			{
+				name: "OK: sort=[mostPoints ASC, serverKey ASC, id ASC]",
+				params: func(t *testing.T) domain.ListTribesParams {
+					t.Helper()
+					params := domain.NewListTribesParams()
+					require.NoError(t, params.SetSort([]domain.TribeSort{
+						domain.TribeSortMostPointsASC,
+						domain.TribeSortServerKeyASC,
+						domain.TribeSortIDASC,
+					}))
+					return params
+				},
+				assertResult: func(t *testing.T, _ domain.ListTribesParams, res domain.ListTribesResult) {
+					t.Helper()
+					tribes := res.Tribes()
+					assert.NotEmpty(t, tribes)
+					assert.True(t, slices.IsSortedFunc(tribes, func(a, b domain.Tribe) int {
+						return cmp.Or(
+							cmp.Compare(a.MostPoints(), b.MostPoints()),
+							cmp.Compare(a.ServerKey(), b.ServerKey()),
+							cmp.Compare(a.ID(), b.ID()),
+						)
+					}))
+				},
+			},
+			{
+				name: "OK: sort=[mostPoints DESC, serverKey ASC, id ASC]",
+				params: func(t *testing.T) domain.ListTribesParams {
+					t.Helper()
+					params := domain.NewListTribesParams()
+					require.NoError(t, params.SetSort([]domain.TribeSort{
+						domain.TribeSortMostPointsDESC,
+						domain.TribeSortServerKeyASC,
+						domain.TribeSortIDASC,
+					}))
+					return params
+				},
+				assertResult: func(t *testing.T, _ domain.ListTribesParams, res domain.ListTribesResult) {
+					t.Helper()
+					tribes := res.Tribes()
+					assert.NotEmpty(t, tribes)
+					assert.True(t, slices.IsSortedFunc(tribes, func(a, b domain.Tribe) int {
+						return cmp.Or(
+							cmp.Compare(a.MostPoints(), b.MostPoints())*-1,
+							cmp.Compare(a.ServerKey(), b.ServerKey()),
+							cmp.Compare(a.ID(), b.ID()),
+						)
+					}))
+				},
+			},
 			{
 				name: "OK: sort=[deletedAt ASC, serverKey ASC, id ASC]",
 				params: func(t *testing.T) domain.ListTribesParams {

internal/app/service_server_snapshot.go

@@ -11,6 +11,10 @@ type ServerSnapshotRepository interface {
 	// Create persists tribe snapshots in a store (e.g. Postgres).
 	// Duplicates are ignored.
 	Create(ctx context.Context, params ...domain.CreateServerSnapshotParams) error
+	ListWithRelations(
+		ctx context.Context,
+		params domain.ListServerSnapshotsParams,
+	) (domain.ListServerSnapshotsWithRelationsResult, error)
 }
 
 type ServerSnapshotService struct {
@@ -27,7 +31,6 @@ func NewServerSnapshotService(
 	return &ServerSnapshotService{repo: repo, serverSvc: serverSvc, pub: pub}
 }
 
-//nolint:gocyclo
 func (svc *ServerSnapshotService) Create(
 	ctx context.Context,
 	createSnapshotsCmdPayload domain.CreateSnapshotsCmdPayload,
@@ -60,3 +63,10 @@ func (svc *ServerSnapshotService) Create(
 
 	return nil
 }
+
+func (svc *ServerSnapshotService) ListWithRelations(
+	ctx context.Context,
+	params domain.ListServerSnapshotsParams,
+) (domain.ListServerSnapshotsWithRelationsResult, error) {
+	return svc.repo.ListWithRelations(ctx, params)
+}

internal/bun/bunmodel/server_snapshot.go

@@ -13,6 +13,7 @@ type ServerSnapshot struct {
 
 	ID                   int       `bun:"id,pk,autoincrement,identity"`
 	ServerKey            string    `bun:"server_key,nullzero"`
+	Server               Server    `bun:"server,rel:belongs-to,join:server_key=key"`
 	NumPlayers           int       `bun:"num_players"`
 	NumActivePlayers     int       `bun:"num_active_players"`
 	NumInactivePlayers   int       `bun:"num_inactive_players"`
@@ -55,8 +56,26 @@ func (ss ServerSnapshot) ToDomain() (domain.ServerSnapshot, error) {
 	return converted, nil
 }
 
+func (ss ServerSnapshot) ToDomainWithRelations() (domain.ServerSnapshotWithRelations, error) {
+	converted, err := ss.ToDomain()
+	if err != nil {
+		return domain.ServerSnapshotWithRelations{}, err
+	}
+
+	server, err := ss.Server.ToMeta()
+	if err != nil {
+		return domain.ServerSnapshotWithRelations{}, err
+	}
+
+	return converted.WithRelations(server), nil
+}
+
 type ServerSnapshots []ServerSnapshot
 
 func (sss ServerSnapshots) ToDomain() (domain.ServerSnapshots, error) {
 	return sliceToDomain(sss)
 }
+
+func (sss ServerSnapshots) ToDomainWithRelations() (domain.ServerSnapshotsWithRelations, error) {
+	return sliceToDomainWithRelations(sss)
+}

internal/domain/base_ennoblement.go

@@ -26,7 +26,7 @@ func NewBaseEnnoblement(
 	points int,
 	createdAt time.Time,
 ) (BaseEnnoblement, error) {
-	if err := validateIntInRange(villageID, 1, math.MaxInt); err != nil {
+	if err := validateInRange(villageID, 1, math.MaxInt); err != nil {
 		return BaseEnnoblement{}, ValidationError{
 			Model: baseEnnoblementModelName,
 			Field: "villageID",
@@ -34,7 +34,7 @@ func NewBaseEnnoblement(
 		}
 	}
 
-	if err := validateIntInRange(newOwnerID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(newOwnerID, 0, math.MaxInt); err != nil {
 		return BaseEnnoblement{}, ValidationError{
 			Model: baseEnnoblementModelName,
 			Field: "newOwnerID",
@@ -42,7 +42,7 @@ func NewBaseEnnoblement(
 		}
 	}
 
-	if err := validateIntInRange(newTribeID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(newTribeID, 0, math.MaxInt); err != nil {
 		return BaseEnnoblement{}, ValidationError{
 			Model: baseEnnoblementModelName,
 			Field: "newTribeID",
@@ -50,7 +50,7 @@ func NewBaseEnnoblement(
 		}
 	}
 
-	if err := validateIntInRange(oldOwnerID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(oldOwnerID, 0, math.MaxInt); err != nil {
 		return BaseEnnoblement{}, ValidationError{
 			Model: baseEnnoblementModelName,
 			Field: "oldOwnerID",
@@ -58,7 +58,7 @@ func NewBaseEnnoblement(
 		}
 	}
 
-	if err := validateIntInRange(oldTribeID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(oldTribeID, 0, math.MaxInt); err != nil {
 		return BaseEnnoblement{}, ValidationError{
 			Model: baseEnnoblementModelName,
 			Field: "oldTribeID",
@@ -66,7 +66,7 @@ func NewBaseEnnoblement(
 		}
 	}
 
-	if err := validateIntInRange(points, 0, math.MaxInt); err != nil {
+	if err := validateInRange(points, 0, math.MaxInt); err != nil {
 		return BaseEnnoblement{}, ValidationError{
 			Model: baseEnnoblementModelName,
 			Field: "points",

internal/domain/base_ennoblement_test.go

@@ -56,7 +56,7 @@ func TestNewBaseEnnoblement(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseEnnoblement",
 				Field: "villageID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -76,7 +76,7 @@ func TestNewBaseEnnoblement(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseEnnoblement",
 				Field: "newOwnerID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -96,7 +96,7 @@ func TestNewBaseEnnoblement(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseEnnoblement",
 				Field: "newTribeID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -116,7 +116,7 @@ func TestNewBaseEnnoblement(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseEnnoblement",
 				Field: "oldOwnerID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -136,7 +136,7 @@ func TestNewBaseEnnoblement(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseEnnoblement",
 				Field: "oldTribeID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -156,7 +156,7 @@ func TestNewBaseEnnoblement(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseEnnoblement",
 				Field: "points",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},

internal/domain/base_player.go

@@ -28,7 +28,7 @@ func NewBasePlayer(
 	od OpponentsDefeated,
 	profileURL *url.URL,
 ) (BasePlayer, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return BasePlayer{}, ValidationError{
 			Model: basePlayerModelName,
 			Field: "id",
@@ -44,7 +44,7 @@ func NewBasePlayer(
 		}
 	}
 
-	if err := validateIntInRange(numVillages, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numVillages, 0, math.MaxInt); err != nil {
 		return BasePlayer{}, ValidationError{
 			Model: basePlayerModelName,
 			Field: "numVillages",
@@ -52,7 +52,7 @@ func NewBasePlayer(
 		}
 	}
 
-	if err := validateIntInRange(points, 0, math.MaxInt); err != nil {
+	if err := validateInRange(points, 0, math.MaxInt); err != nil {
 		return BasePlayer{}, ValidationError{
 			Model: basePlayerModelName,
 			Field: "points",
@@ -60,7 +60,7 @@ func NewBasePlayer(
 		}
 	}
 
-	if err := validateIntInRange(rank, 0, math.MaxInt); err != nil {
+	if err := validateInRange(rank, 0, math.MaxInt); err != nil {
 		return BasePlayer{}, ValidationError{
 			Model: basePlayerModelName,
 			Field: "rank",
@@ -68,7 +68,7 @@ func NewBasePlayer(
 		}
 	}
 
-	if err := validateIntInRange(tribeID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(tribeID, 0, math.MaxInt); err != nil {
 		return BasePlayer{}, ValidationError{
 			Model: basePlayerModelName,
 			Field: "tribeID",

internal/domain/base_player_test.go

@@ -60,7 +60,7 @@ func TestNewBasePlayer(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BasePlayer",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -125,7 +125,7 @@ func TestNewBasePlayer(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BasePlayer",
 				Field: "numVillages",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -146,7 +146,7 @@ func TestNewBasePlayer(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BasePlayer",
 				Field: "points",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -167,7 +167,7 @@ func TestNewBasePlayer(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BasePlayer",
 				Field: "rank",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -188,7 +188,7 @@ func TestNewBasePlayer(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BasePlayer",
 				Field: "tribeID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},

internal/domain/base_tribe.go

@@ -33,7 +33,7 @@ func NewBaseTribe(
 	od OpponentsDefeated,
 	profileURL *url.URL,
 ) (BaseTribe, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return BaseTribe{}, ValidationError{
 			Model: baseTribeModelName,
 			Field: "id",
@@ -60,7 +60,7 @@ func NewBaseTribe(
 		}
 	}
 
-	if err := validateIntInRange(numMembers, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numMembers, 0, math.MaxInt); err != nil {
 		return BaseTribe{}, ValidationError{
 			Model: baseTribeModelName,
 			Field: "numMembers",
@@ -68,7 +68,7 @@ func NewBaseTribe(
 		}
 	}
 
-	if err := validateIntInRange(numVillages, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numVillages, 0, math.MaxInt); err != nil {
 		return BaseTribe{}, ValidationError{
 			Model: baseTribeModelName,
 			Field: "numVillages",
@@ -76,7 +76,7 @@ func NewBaseTribe(
 		}
 	}
 
-	if err := validateIntInRange(points, 0, math.MaxInt); err != nil {
+	if err := validateInRange(points, 0, math.MaxInt); err != nil {
 		return BaseTribe{}, ValidationError{
 			Model: baseTribeModelName,
 			Field: "points",
@@ -84,7 +84,7 @@ func NewBaseTribe(
 		}
 	}
 
-	if err := validateIntInRange(allPoints, 0, math.MaxInt); err != nil {
+	if err := validateInRange(allPoints, 0, math.MaxInt); err != nil {
 		return BaseTribe{}, ValidationError{
 			Model: baseTribeModelName,
 			Field: "allPoints",
@@ -92,7 +92,7 @@ func NewBaseTribe(
 		}
 	}
 
-	if err := validateIntInRange(rank, 0, math.MaxInt); err != nil {
+	if err := validateInRange(rank, 0, math.MaxInt); err != nil {
 		return BaseTribe{}, ValidationError{
 			Model: baseTribeModelName,
 			Field: "rank",

internal/domain/base_tribe_test.go

@@ -81,7 +81,7 @@ func TestNewBaseTribe(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseTribe",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -200,7 +200,7 @@ func TestNewBaseTribe(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseTribe",
 				Field: "numMembers",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -223,7 +223,7 @@ func TestNewBaseTribe(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseTribe",
 				Field: "numVillages",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -246,7 +246,7 @@ func TestNewBaseTribe(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseTribe",
 				Field: "points",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -269,7 +269,7 @@ func TestNewBaseTribe(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseTribe",
 				Field: "allPoints",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -292,7 +292,7 @@ func TestNewBaseTribe(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseTribe",
 				Field: "rank",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},

internal/domain/base_village.go

@@ -29,7 +29,7 @@ func NewBaseVillage(
 	playerID int,
 	profileURL *url.URL,
 ) (BaseVillage, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return BaseVillage{}, ValidationError{
 			Model: baseVillageModelName,
 			Field: "id",
@@ -45,7 +45,7 @@ func NewBaseVillage(
 		}
 	}
 
-	if err := validateIntInRange(points, 0, math.MaxInt); err != nil {
+	if err := validateInRange(points, 0, math.MaxInt); err != nil {
 		return BaseVillage{}, ValidationError{
 			Model: baseVillageModelName,
 			Field: "points",
@@ -53,7 +53,7 @@ func NewBaseVillage(
 		}
 	}
 
-	if err := validateIntInRange(x, 0, math.MaxInt); err != nil {
+	if err := validateInRange(x, 0, math.MaxInt); err != nil {
 		return BaseVillage{}, ValidationError{
 			Model: baseVillageModelName,
 			Field: "x",
@@ -61,7 +61,7 @@ func NewBaseVillage(
 		}
 	}
 
-	if err := validateIntInRange(y, 0, math.MaxInt); err != nil {
+	if err := validateInRange(y, 0, math.MaxInt); err != nil {
 		return BaseVillage{}, ValidationError{
 			Model: baseVillageModelName,
 			Field: "y",
@@ -77,7 +77,7 @@ func NewBaseVillage(
 		}
 	}
 
-	if err := validateIntInRange(bonus, 0, math.MaxInt); err != nil {
+	if err := validateInRange(bonus, 0, math.MaxInt); err != nil {
 		return BaseVillage{}, ValidationError{
 			Model: baseVillageModelName,
 			Field: "bonus",
@@ -85,7 +85,7 @@ func NewBaseVillage(
 		}
 	}
 
-	if err := validateIntInRange(playerID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(playerID, 0, math.MaxInt); err != nil {
 		return BaseVillage{}, ValidationError{
 			Model: baseVillageModelName,
 			Field: "playerID",

internal/domain/base_village_test.go

@@ -63,7 +63,7 @@ func TestNewBaseVillage(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseVillage",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -131,7 +131,7 @@ func TestNewBaseVillage(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseVillage",
 				Field: "points",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -153,7 +153,7 @@ func TestNewBaseVillage(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseVillage",
 				Field: "x",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -175,7 +175,7 @@ func TestNewBaseVillage(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseVillage",
 				Field: "y",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -243,7 +243,7 @@ func TestNewBaseVillage(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseVillage",
 				Field: "bonus",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -265,7 +265,7 @@ func TestNewBaseVillage(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "BaseVillage",
 				Field: "playerID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},

internal/domain/domaintest/player.go

@@ -17,6 +17,7 @@ type PlayerCursorConfig struct {
 	ODScoreSup   int
 	ODScoreTotal int
 	Points       int
+	MostPoints   int
 	DeletedAt    time.Time
 }
 
@@ -31,6 +32,7 @@ func NewPlayerCursor(tb TestingTB, opts ...func(cfg *PlayerCursorConfig)) domain
 		ODScoreSup:   gofakeit.IntRange(0, math.MaxInt),
 		ODScoreTotal: gofakeit.IntRange(0, math.MaxInt),
 		Points:       gofakeit.IntRange(0, math.MaxInt),
+		MostPoints:   gofakeit.IntRange(0, math.MaxInt),
 		DeletedAt:    time.Time{},
 	}
 
@@ -46,6 +48,7 @@ func NewPlayerCursor(tb TestingTB, opts ...func(cfg *PlayerCursorConfig)) domain
 		cfg.ODScoreSup,
 		cfg.ODScoreTotal,
 		cfg.Points,
+		cfg.MostPoints,
 		cfg.DeletedAt,
 	)
 	require.NoError(tb, err)

internal/domain/domaintest/server_config.go

@@ -20,7 +20,9 @@ func NewServerConfig(tb TestingTB) domain.ServerConfig {
 		domain.ServerConfigBuildings{},
 		domain.ServerConfigSnob{},
 		domain.ServerConfigAlly{Limit: gofakeit.IntRange(1, 20)},
-		domain.ServerConfigCoord{},
+		domain.ServerConfigCoord{
+			MapSize: gofakeit.IntRange(1000, 1000),
+		},
 		domain.ServerConfigSitter{},
 		domain.ServerConfigSleep{},
 		domain.ServerConfigNight{},

internal/domain/domaintest/server_snapshot.go

@@ -100,3 +100,38 @@ func NewServerSnapshot(tb TestingTB, opts ...func(cfg *ServerSnapshotConfig)) do
 
 	return ss
 }
+
+type ServerSnapshotWithRelationsConfig struct {
+	ServerSnapshotOptions []func(cfg *ServerSnapshotConfig)
+	ServerOptions         []func(cfg *ServerConfig)
+}
+
+func NewServerSnapshotWithRelations(
+	tb TestingTB,
+	opts ...func(cfg *ServerSnapshotWithRelationsConfig),
+) domain.ServerSnapshotWithRelations {
+	tb.Helper()
+
+	cfg := &ServerSnapshotWithRelationsConfig{}
+
+	for _, opt := range opts {
+		opt(cfg)
+	}
+
+	ss := NewServerSnapshot(tb, cfg.ServerSnapshotOptions...)
+
+	if ss.ServerKey() != "" {
+		cfg.ServerOptions = append([]func(cfg *ServerConfig){
+			func(cfg *ServerConfig) {
+				cfg.Key = ss.ServerKey()
+			},
+		}, cfg.ServerOptions...)
+	}
+
+	var tribe domain.ServerMeta
+	if len(cfg.ServerOptions) > 0 {
+		tribe = NewServer(tb, cfg.ServerOptions...).Meta()
+	}
+
+	return ss.WithRelations(tribe)
+}

internal/domain/domaintest/tribe.go

@@ -20,6 +20,7 @@ type TribeCursorConfig struct {
 	ODScoreDef   int
 	ODScoreTotal int
 	Points       int
+	MostPoints   int
 	Dominance    float64
 	DeletedAt    time.Time
 }
@@ -34,6 +35,7 @@ func NewTribeCursor(tb TestingTB, opts ...func(cfg *TribeCursorConfig)) domain.T
 		ODScoreDef:   gofakeit.IntRange(0, math.MaxInt),
 		ODScoreTotal: gofakeit.IntRange(0, math.MaxInt),
 		Points:       gofakeit.IntRange(0, math.MaxInt),
+		MostPoints:   gofakeit.IntRange(0, math.MaxInt),
 		Dominance:    gofakeit.Float64Range(0.1, 99.9),
 		DeletedAt:    time.Time{},
 	}
@@ -49,6 +51,7 @@ func NewTribeCursor(tb TestingTB, opts ...func(cfg *TribeCursorConfig)) domain.T
 		cfg.ODScoreDef,
 		cfg.ODScoreTotal,
 		cfg.Points,
+		cfg.MostPoints,
 		cfg.Dominance,
 		cfg.DeletedAt,
 	)

internal/domain/domaintest/village.go

@@ -37,6 +37,8 @@ func NewVillageCursor(tb TestingTB, opts ...func(cfg *VillageCursorConfig)) doma
 type VillageConfig struct {
 	ID        int
 	ServerKey string
+	X         int
+	Y         int
 	PlayerID  int
 }
 
@@ -46,6 +48,8 @@ func NewVillage(tb TestingTB, opts ...func(cfg *VillageConfig)) domain.Village {
 	cfg := &VillageConfig{
 		ID:        RandID(),
 		ServerKey: RandServerKey(),
+		X:         gofakeit.IntRange(1, 999),
+		Y:         gofakeit.IntRange(1, 999),
 		PlayerID:  gofakeit.IntRange(0, 10000),
 	}
 
@@ -58,8 +62,8 @@ func NewVillage(tb TestingTB, opts ...func(cfg *VillageConfig)) domain.Village {
 		cfg.ServerKey,
 		gofakeit.LetterN(50),
 		gofakeit.IntRange(1, 10000),
-		gofakeit.IntRange(1, 999),
-		gofakeit.IntRange(1, 999),
+		cfg.X,
+		cfg.Y,
 		gofakeit.LetterN(3),
 		0,
 		cfg.PlayerID,

internal/domain/ennoblement.go

@@ -37,7 +37,7 @@ func UnmarshalEnnoblementFromDatabase(
 	points int,
 	createdAt time.Time,
 ) (Ennoblement, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return Ennoblement{}, ValidationError{
 			Model: ennoblementModelName,
 			Field: "id",
@@ -265,7 +265,7 @@ type EnnoblementCursor struct {
 const ennoblementCursorModelName = "EnnoblementCursor"
 
 func NewEnnoblementCursor(id int, serverKey string, createdAt time.Time) (EnnoblementCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return EnnoblementCursor{}, ValidationError{
 			Model: ennoblementCursorModelName,
 			Field: "id",
@@ -405,7 +405,7 @@ func (params *ListEnnoblementsParams) VillageIDs() []int {
 
 func (params *ListEnnoblementsParams) SetVillageIDs(villageIDs []int) error {
 	for i, id := range villageIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listEnnoblementsParamsModelName,
 				Field: "villageIDs",
@@ -426,7 +426,7 @@ func (params *ListEnnoblementsParams) PlayerIDs() []int {
 
 func (params *ListEnnoblementsParams) SetPlayerIDs(playerIDs []int) error {
 	for i, id := range playerIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listEnnoblementsParamsModelName,
 				Field: "playerIDs",
@@ -447,7 +447,7 @@ func (params *ListEnnoblementsParams) TribeIDs() []int {
 
 func (params *ListEnnoblementsParams) SetTribeIDs(tribeIDs []int) error {
 	for i, id := range tribeIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listEnnoblementsParamsModelName,
 				Field: "tribeIDs",
@@ -579,7 +579,7 @@ func (params *ListEnnoblementsParams) Limit() int {
 }
 
 func (params *ListEnnoblementsParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, EnnoblementListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, EnnoblementListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listEnnoblementsParamsModelName,
 			Field: "limit",

internal/domain/ennoblement_test.go

@@ -141,7 +141,7 @@ func TestNewEnnoblementCursor(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "EnnoblementCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -276,7 +276,7 @@ func TestListEnnoblementsParams_SetVillageIDs(t *testing.T) {
 				Model: "ListEnnoblementsParams",
 				Field: "villageIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -336,7 +336,7 @@ func TestListEnnoblementsParams_SetPlayerIDs(t *testing.T) {
 				Model: "ListEnnoblementsParams",
 				Field: "playerIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -396,7 +396,7 @@ func TestListEnnoblementsParams_SetTribeIDs(t *testing.T) {
 				Model: "ListEnnoblementsParams",
 				Field: "tribeIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -957,7 +957,7 @@ func TestListEnnoblementsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListEnnoblementsParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -971,7 +971,7 @@ func TestListEnnoblementsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListEnnoblementsParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.EnnoblementListMaxLimit,
 					Current: domain.EnnoblementListMaxLimit + 1,
 				},

internal/domain/message_payloads.go

@@ -149,7 +149,7 @@ func NewTribesSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numTribes, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numTribes, 0, math.MaxInt); err != nil {
 		return TribesSyncedEventPayload{}, ValidationError{
 			Model: tribesSyncedEventPayloadModelName,
 			Field: "numTribes",
@@ -157,7 +157,7 @@ func NewTribesSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numActiveTribes, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numActiveTribes, 0, math.MaxInt); err != nil {
 		return TribesSyncedEventPayload{}, ValidationError{
 			Model: tribesSyncedEventPayloadModelName,
 			Field: "numActiveTribes",
@@ -239,7 +239,7 @@ func NewPlayersSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numPlayers, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numPlayers, 0, math.MaxInt); err != nil {
 		return PlayersSyncedEventPayload{}, ValidationError{
 			Model: playersSyncedEventPayloadModelName,
 			Field: "numPlayers",
@@ -247,7 +247,7 @@ func NewPlayersSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numActivePlayers, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numActivePlayers, 0, math.MaxInt); err != nil {
 		return PlayersSyncedEventPayload{}, ValidationError{
 			Model: playersSyncedEventPayloadModelName,
 			Field: "numActivePlayers",
@@ -333,7 +333,7 @@ func NewVillagesSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numVillages, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numVillages, 0, math.MaxInt); err != nil {
 		return VillagesSyncedEventPayload{}, ValidationError{
 			Model: villagesSyncedEventPayloadModelName,
 			Field: "numVillages",
@@ -341,7 +341,7 @@ func NewVillagesSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numPlayerVillages, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numPlayerVillages, 0, math.MaxInt); err != nil {
 		return VillagesSyncedEventPayload{}, ValidationError{
 			Model: villagesSyncedEventPayloadModelName,
 			Field: "numPlayerVillages",
@@ -349,7 +349,7 @@ func NewVillagesSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numBarbarianVillages, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numBarbarianVillages, 0, math.MaxInt); err != nil {
 		return VillagesSyncedEventPayload{}, ValidationError{
 			Model: villagesSyncedEventPayloadModelName,
 			Field: "numBarbarianVillages",
@@ -357,7 +357,7 @@ func NewVillagesSyncedEventPayload(
 		}
 	}
 
-	if err := validateIntInRange(numBonusVillages, 0, math.MaxInt); err != nil {
+	if err := validateInRange(numBonusVillages, 0, math.MaxInt); err != nil {
 		return VillagesSyncedEventPayload{}, ValidationError{
 			Model: villagesSyncedEventPayloadModelName,
 			Field: "numBonusVillages",

internal/domain/opponents_defeated.go

@@ -25,7 +25,7 @@ func NewOpponentsDefeated(
 	rankTotal int,
 	scoreTotal int,
 ) (OpponentsDefeated, error) {
-	if err := validateIntInRange(rankAtt, 0, math.MaxInt); err != nil {
+	if err := validateInRange(rankAtt, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "rankAtt",
@@ -33,7 +33,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(scoreAtt, 0, math.MaxInt); err != nil {
+	if err := validateInRange(scoreAtt, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "scoreAtt",
@@ -41,7 +41,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(rankDef, 0, math.MaxInt); err != nil {
+	if err := validateInRange(rankDef, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "rankDef",
@@ -49,7 +49,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(scoreDef, 0, math.MaxInt); err != nil {
+	if err := validateInRange(scoreDef, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "scoreDef",
@@ -57,7 +57,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(rankSup, 0, math.MaxInt); err != nil {
+	if err := validateInRange(rankSup, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "rankSup",
@@ -65,7 +65,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(scoreSup, 0, math.MaxInt); err != nil {
+	if err := validateInRange(scoreSup, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "scoreSup",
@@ -73,7 +73,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(rankTotal, 0, math.MaxInt); err != nil {
+	if err := validateInRange(rankTotal, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "rankTotal",
@@ -81,7 +81,7 @@ func NewOpponentsDefeated(
 		}
 	}
 
-	if err := validateIntInRange(scoreTotal, 0, math.MaxInt); err != nil {
+	if err := validateInRange(scoreTotal, 0, math.MaxInt); err != nil {
 		return OpponentsDefeated{}, ValidationError{
 			Model: opponentsDefeatedModelName,
 			Field: "scoreTotal",

internal/domain/opponents_defeated_test.go

@@ -58,7 +58,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "rankAtt",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -79,7 +79,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "scoreAtt",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -100,7 +100,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "rankDef",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -121,7 +121,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "scoreDef",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -142,7 +142,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "rankSup",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -163,7 +163,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "scoreSup",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -184,7 +184,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "rankTotal",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -205,7 +205,7 @@ func TestNewOpponentsDefeated(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "OpponentsDefeated",
 				Field: "scoreTotal",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},

internal/domain/player.go

@@ -61,7 +61,7 @@ func UnmarshalPlayerFromDatabase(
 	createdAt time.Time,
 	deletedAt time.Time,
 ) (Player, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return Player{}, ValidationError{
 			Model: playerModelName,
 			Field: "id",
@@ -200,6 +200,7 @@ func (p Player) ToCursor() (PlayerCursor, error) {
 		p.od.scoreSup,
 		p.od.scoreTotal,
 		p.points,
+		p.mostPoints,
 		p.deletedAt,
 	)
 }
@@ -326,7 +327,7 @@ const playerMetaModelName = "PlayerMeta"
 // It should be used only for unmarshalling from the database!
 // You can't use UnmarshalPlayerMetaFromDatabase as constructor - It may put domain into the invalid state!
 func UnmarshalPlayerMetaFromDatabase(id int, name string, rawProfileURL string) (PlayerMeta, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return PlayerMeta{}, ValidationError{
 			Model: playerMetaModelName,
 			Field: "id",
@@ -552,6 +553,8 @@ const (
 	PlayerSortODScoreTotalDESC
 	PlayerSortPointsASC
 	PlayerSortPointsDESC
+	PlayerSortMostPointsASC
+	PlayerSortMostPointsDESC
 	PlayerSortDeletedAtASC
 	PlayerSortDeletedAtDESC
 )
@@ -592,6 +595,10 @@ func (s PlayerSort) String() string {
 		return "points:ASC"
 	case PlayerSortPointsDESC:
 		return "points:DESC"
+	case PlayerSortMostPointsASC:
+		return "mostPoints:ASC"
+	case PlayerSortMostPointsDESC:
+		return "mostPoints:DESC"
 	case PlayerSortDeletedAtASC:
 		return "deletedAt:ASC"
 	case PlayerSortDeletedAtDESC:
@@ -609,6 +616,7 @@ type PlayerCursor struct {
 	odScoreSup   int
 	odScoreTotal int
 	points       int
+	mostPoints   int
 	deletedAt    time.Time
 }
 
@@ -622,9 +630,10 @@ func NewPlayerCursor(
 	odScoreSup int,
 	odScoreTotal int,
 	points int,
+	mostPoints int,
 	deletedAt time.Time,
 ) (PlayerCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return PlayerCursor{}, ValidationError{
 			Model: playerCursorModelName,
 			Field: "id",
@@ -640,7 +649,7 @@ func NewPlayerCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreAtt, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreAtt, 0, math.MaxInt); err != nil {
 		return PlayerCursor{}, ValidationError{
 			Model: playerCursorModelName,
 			Field: "odScoreAtt",
@@ -648,7 +657,7 @@ func NewPlayerCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreDef, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreDef, 0, math.MaxInt); err != nil {
 		return PlayerCursor{}, ValidationError{
 			Model: playerCursorModelName,
 			Field: "odScoreDef",
@@ -656,7 +665,7 @@ func NewPlayerCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreSup, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreSup, 0, math.MaxInt); err != nil {
 		return PlayerCursor{}, ValidationError{
 			Model: playerCursorModelName,
 			Field: "odScoreSup",
@@ -664,7 +673,7 @@ func NewPlayerCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreTotal, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreTotal, 0, math.MaxInt); err != nil {
 		return PlayerCursor{}, ValidationError{
 			Model: playerCursorModelName,
 			Field: "odScoreTotal",
@@ -672,7 +681,7 @@ func NewPlayerCursor(
 		}
 	}
 
-	if err := validateIntInRange(points, 0, math.MaxInt); err != nil {
+	if err := validateInRange(points, 0, math.MaxInt); err != nil {
 		return PlayerCursor{}, ValidationError{
 			Model: playerCursorModelName,
 			Field: "points",
@@ -680,6 +689,14 @@ func NewPlayerCursor(
 		}
 	}
 
+	if err := validateInRange(mostPoints, 0, math.MaxInt); err != nil {
+		return PlayerCursor{}, ValidationError{
+			Model: playerCursorModelName,
+			Field: "mostPoints",
+			Err:   err,
+		}
+	}
+
 	return PlayerCursor{
 		id:           id,
 		serverKey:    serverKey,
@@ -688,6 +705,7 @@ func NewPlayerCursor(
 		odScoreSup:   odScoreSup,
 		odScoreTotal: odScoreTotal,
 		points:       points,
+		mostPoints:   mostPoints,
 		deletedAt:    deletedAt,
 	}, nil
 }
@@ -734,6 +752,11 @@ func decodePlayerCursor(encoded string) (PlayerCursor, error) {
 		return PlayerCursor{}, ErrInvalidCursor
 	}
 
+	mostPoints, err := m.int("mostPoints")
+	if err != nil {
+		return PlayerCursor{}, ErrInvalidCursor
+	}
+
 	deletedAt, err := m.time("deletedAt")
 	if err != nil {
 		return PlayerCursor{}, ErrInvalidCursor
@@ -747,6 +770,7 @@ func decodePlayerCursor(encoded string) (PlayerCursor, error) {
 		odScoreSup,
 		odScoreTotal,
 		points,
+		mostPoints,
 		deletedAt,
 	)
 	if err != nil {
@@ -784,6 +808,10 @@ func (pc PlayerCursor) Points() int {
 	return pc.points
 }
 
+func (pc PlayerCursor) MostPoints() int {
+	return pc.mostPoints
+}
+
 func (pc PlayerCursor) DeletedAt() time.Time {
 	return pc.deletedAt
 }
@@ -805,6 +833,7 @@ func (pc PlayerCursor) Encode() string {
 		{"odScoreSup", pc.odScoreSup},
 		{"odScoreTotal", pc.odScoreTotal},
 		{"points", pc.points},
+		{"mostPoints", pc.mostPoints},
 		{"deletedAt", pc.deletedAt},
 	})
 }
@@ -842,7 +871,7 @@ func (params *ListPlayersParams) IDs() []int {
 
 func (params *ListPlayersParams) SetIDs(ids []int) error {
 	for i, id := range ids {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listPlayersParamsModelName,
 				Field: "ids",
@@ -939,7 +968,7 @@ func (params *ListPlayersParams) TribeIDs() []int {
 
 func (params *ListPlayersParams) SetTribeIDs(tribeIDs []int) error {
 	for i, id := range tribeIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listPlayersParamsModelName,
 				Field: "tribeIDs",
@@ -1062,7 +1091,7 @@ func (params *ListPlayersParams) Limit() int {
 }
 
 func (params *ListPlayersParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, PlayerListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, PlayerListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listPlayersParamsModelName,
 			Field: "limit",

internal/domain/player_snapshot.go

@@ -39,7 +39,7 @@ func UnmarshalPlayerSnapshotFromDatabase(
 	date time.Time,
 	createdAt time.Time,
 ) (PlayerSnapshot, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return PlayerSnapshot{}, ValidationError{
 			Model: playerSnapshotModelName,
 			Field: "id",
@@ -47,7 +47,7 @@ func UnmarshalPlayerSnapshotFromDatabase(
 		}
 	}
 
-	if err := validateIntInRange(playerID, 1, math.MaxInt); err != nil {
+	if err := validateInRange(playerID, 1, math.MaxInt); err != nil {
 		return PlayerSnapshot{}, ValidationError{
 			Model: playerSnapshotModelName,
 			Field: "playerID",
@@ -275,7 +275,7 @@ type PlayerSnapshotCursor struct {
 const playerSnapshotCursorModelName = "PlayerSnapshotCursor"
 
 func NewPlayerSnapshotCursor(id int, serverKey string, date time.Time) (PlayerSnapshotCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return PlayerSnapshotCursor{}, ValidationError{
 			Model: playerSnapshotCursorModelName,
 			Field: "id",
@@ -411,7 +411,7 @@ func (params *ListPlayerSnapshotsParams) PlayerIDs() []int {
 
 func (params *ListPlayerSnapshotsParams) SetPlayerIDs(playerIDs []int) error {
 	for i, id := range playerIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listPlayerSnapshotsParamsModelName,
 				Field: "playerIDs",
@@ -529,7 +529,7 @@ func (params *ListPlayerSnapshotsParams) Limit() int {
 }
 
 func (params *ListPlayerSnapshotsParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, PlayerSnapshotListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, PlayerSnapshotListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listPlayerSnapshotsParamsModelName,
 			Field: "limit",

internal/domain/player_snapshot_test.go

@@ -147,7 +147,7 @@ func TestNewPlayerSnapshotCursor(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "PlayerSnapshotCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -282,7 +282,7 @@ func TestListPlayerSnapshotsParams_SetPlayerIDs(t *testing.T) {
 				Model: "ListPlayerSnapshotsParams",
 				Field: "playerIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -840,7 +840,7 @@ func TestListPlayerSnapshotsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListPlayerSnapshotsParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -854,7 +854,7 @@ func TestListPlayerSnapshotsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListPlayerSnapshotsParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.PlayerSnapshotListMaxLimit,
 					Current: domain.PlayerSnapshotListMaxLimit + 1,
 				},

internal/domain/player_test.go

@@ -303,6 +303,13 @@ func TestPlayerSort_IsInConflict(t *testing.T) {
 			},
 			expectedRes: true,
 		},
+		{
+			name: "OK: mostPoints:ASC mostPoints:DESC",
+			args: args{
+				sorts: [2]domain.PlayerSort{domain.PlayerSortMostPointsASC, domain.PlayerSortMostPointsDESC},
+			},
+			expectedRes: true,
+		},
 		{
 			name: "OK: deletedAt:ASC deletedAt:DESC",
 			args: args{
@@ -334,6 +341,7 @@ func TestNewPlayerCursor(t *testing.T) {
 		odScoreSup   int
 		odScoreTotal int
 		points       int
+		mostPoints   int
 		deletedAt    time.Time
 	}
 
@@ -354,6 +362,7 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   validPlayerCursor.ODScoreSup(),
 				odScoreTotal: validPlayerCursor.ODScoreTotal(),
 				points:       validPlayerCursor.Points(),
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: nil,
@@ -368,12 +377,13 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   validPlayerCursor.ODScoreSup(),
 				odScoreTotal: validPlayerCursor.ODScoreTotal(),
 				points:       validPlayerCursor.Points(),
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "PlayerCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -389,12 +399,13 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   validPlayerCursor.ODScoreSup(),
 				odScoreTotal: validPlayerCursor.ODScoreTotal(),
 				points:       validPlayerCursor.Points(),
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "PlayerCursor",
 				Field: "odScoreAtt",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -410,12 +421,13 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   validPlayerCursor.ODScoreSup(),
 				odScoreTotal: validPlayerCursor.ODScoreTotal(),
 				points:       validPlayerCursor.Points(),
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "PlayerCursor",
 				Field: "odScoreDef",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -431,12 +443,13 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   -1,
 				odScoreTotal: validPlayerCursor.ODScoreTotal(),
 				points:       validPlayerCursor.Points(),
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "PlayerCursor",
 				Field: "odScoreSup",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -452,12 +465,13 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   validPlayerCursor.ODScoreSup(),
 				odScoreTotal: -1,
 				points:       validPlayerCursor.Points(),
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "PlayerCursor",
 				Field: "odScoreTotal",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -473,12 +487,35 @@ func TestNewPlayerCursor(t *testing.T) {
 				odScoreSup:   validPlayerCursor.ODScoreSup(),
 				odScoreTotal: validPlayerCursor.ODScoreTotal(),
 				points:       -1,
+				mostPoints:   validPlayerCursor.MostPoints(),
 				deletedAt:    validPlayerCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "PlayerCursor",
 				Field: "points",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
+					Min:     0,
+					Current: -1,
+				},
+			},
+		},
+		{
+			name: "ERR: mostPoints < 0",
+			args: args{
+				id:           validPlayerCursor.ID(),
+				serverKey:    validPlayerCursor.ServerKey(),
+				odScoreAtt:   validPlayerCursor.ODScoreAtt(),
+				odScoreDef:   validPlayerCursor.ODScoreDef(),
+				odScoreSup:   validPlayerCursor.ODScoreSup(),
+				odScoreTotal: validPlayerCursor.ODScoreTotal(),
+				points:       validPlayerCursor.Points(),
+				mostPoints:   -1,
+				deletedAt:    validPlayerCursor.DeletedAt(),
+			},
+			expectedErr: domain.ValidationError{
+				Model: "PlayerCursor",
+				Field: "mostPoints",
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -518,6 +555,7 @@ func TestNewPlayerCursor(t *testing.T) {
 				tt.args.odScoreSup,
 				tt.args.odScoreTotal,
 				tt.args.points,
+				tt.args.mostPoints,
 				tt.args.deletedAt,
 			)
 			require.ErrorIs(t, err, tt.expectedErr)
@@ -531,6 +569,7 @@ func TestNewPlayerCursor(t *testing.T) {
 			assert.Equal(t, tt.args.odScoreSup, pc.ODScoreSup())
 			assert.Equal(t, tt.args.odScoreTotal, pc.ODScoreTotal())
 			assert.Equal(t, tt.args.points, pc.Points())
+			assert.Equal(t, tt.args.mostPoints, pc.MostPoints())
 			assert.Equal(t, tt.args.deletedAt, pc.DeletedAt())
 			assert.NotEmpty(t, pc.Encode())
 		})
@@ -574,7 +613,7 @@ func TestListPlayersParams_SetIDs(t *testing.T) {
 				Model: "ListPlayersParams",
 				Field: "ids",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -845,7 +884,7 @@ func TestListPlayersParams_SetTribeIDs(t *testing.T) {
 				Model: "ListPlayersParams",
 				Field: "tribeIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1490,7 +1529,7 @@ func TestListPlayersParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListPlayersParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1504,7 +1543,7 @@ func TestListPlayersParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListPlayersParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.PlayerListMaxLimit,
 					Current: domain.PlayerListMaxLimit + 1,
 				},

internal/domain/server.go

@@ -466,7 +466,7 @@ func (params *UpdateServerParams) NumTribes() NullInt {
 
 func (params *UpdateServerParams) SetNumTribes(num NullInt) error {
 	if num.Valid {
-		if err := validateIntInRange(num.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(num.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numTribes",
@@ -486,7 +486,7 @@ func (params *UpdateServerParams) NumActiveTribes() NullInt {
 
 func (params *UpdateServerParams) SetNumActiveTribes(num NullInt) error {
 	if num.Valid {
-		if err := validateIntInRange(num.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(num.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numActiveTribes",
@@ -506,7 +506,7 @@ func (params *UpdateServerParams) NumInactiveTribes() NullInt {
 
 func (params *UpdateServerParams) SetNumInactiveTribes(num NullInt) error {
 	if num.Valid {
-		if err := validateIntInRange(num.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(num.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numInactiveTribes",
@@ -535,7 +535,7 @@ func (params *UpdateServerParams) NumPlayers() NullInt {
 
 func (params *UpdateServerParams) SetNumPlayers(num NullInt) error {
 	if num.Valid {
-		if err := validateIntInRange(num.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(num.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numPlayers",
@@ -555,7 +555,7 @@ func (params *UpdateServerParams) NumActivePlayers() NullInt {
 
 func (params *UpdateServerParams) SetNumActivePlayers(num NullInt) error {
 	if num.Valid {
-		if err := validateIntInRange(num.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(num.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numActivePlayers",
@@ -575,7 +575,7 @@ func (params *UpdateServerParams) NumInactivePlayers() NullInt {
 
 func (params *UpdateServerParams) SetNumInactivePlayers(num NullInt) error {
 	if num.Valid {
-		if err := validateIntInRange(num.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(num.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numInactivePlayers",
@@ -604,7 +604,7 @@ func (params *UpdateServerParams) NumVillages() NullInt {
 
 func (params *UpdateServerParams) SetNumVillages(numVillages NullInt) error {
 	if numVillages.Valid {
-		if err := validateIntInRange(numVillages.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(numVillages.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numVillages",
@@ -624,7 +624,7 @@ func (params *UpdateServerParams) NumPlayerVillages() NullInt {
 
 func (params *UpdateServerParams) SetNumPlayerVillages(numPlayerVillages NullInt) error {
 	if numPlayerVillages.Valid {
-		if err := validateIntInRange(numPlayerVillages.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(numPlayerVillages.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numPlayerVillages",
@@ -644,7 +644,7 @@ func (params *UpdateServerParams) NumBarbarianVillages() NullInt {
 
 func (params *UpdateServerParams) SetNumBarbarianVillages(numBarbarianVillages NullInt) error {
 	if numBarbarianVillages.Valid {
-		if err := validateIntInRange(numBarbarianVillages.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(numBarbarianVillages.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numBarbarianVillages",
@@ -664,7 +664,7 @@ func (params *UpdateServerParams) NumBonusVillages() NullInt {
 
 func (params *UpdateServerParams) SetNumBonusVillages(numBonusVillages NullInt) error {
 	if numBonusVillages.Valid {
-		if err := validateIntInRange(numBonusVillages.V, 0, math.MaxInt); err != nil {
+		if err := validateInRange(numBonusVillages.V, 0, math.MaxInt); err != nil {
 			return ValidationError{
 				Model: updateServerParamsModelName,
 				Field: "numBonusVillages",
@@ -1006,7 +1006,7 @@ func (params *ListServersParams) Limit() int {
 }
 
 func (params *ListServersParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, ServerListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, ServerListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listServersParamsModelName,
 			Field: "limit",

internal/domain/server_map.go

@@ -0,0 +1,385 @@
+package domain
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"io"
+	"strconv"
+
+	"golang.org/x/image/draw"
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/basicfont"
+	"golang.org/x/image/math/fixed"
+)
+
+type ServerMapMarker struct {
+	village VillageMeta
+	color   color.RGBA
+}
+
+func NewServerMapMarker(village VillageMeta) ServerMapMarker {
+	return ServerMapMarker{
+		village: village,
+		color:   color.RGBA{R: 255, G: 99, B: 71, A: 255},
+	}
+}
+
+func (m *ServerMapMarker) Village() VillageMeta {
+	return m.village
+}
+
+func (m *ServerMapMarker) SetColor(c color.RGBA) error {
+	m.color = c
+	return nil
+}
+
+func (m *ServerMapMarker) Color() color.RGBA {
+	return m.color
+}
+
+type ServerMapLegendEntry struct {
+	color color.Color
+	names []string
+}
+
+func NewServerMapLegendEntry(c color.Color, names ...string) ServerMapLegendEntry {
+	return ServerMapLegendEntry{color: c, names: names}
+}
+
+func (e ServerMapLegendEntry) Color() color.Color {
+	return e.color
+}
+
+func (e ServerMapLegendEntry) Names() []string {
+	return e.names
+}
+
+type ServerMap struct {
+	server               Server
+	size                 int
+	markersCh            <-chan ServerMapMarker
+	backgroundColor      color.RGBA
+	scale                float32
+	centerX              int
+	centerY              int
+	continentGrid        bool
+	gridLineColor        color.RGBA
+	continentNumbers     bool
+	continentNumberColor color.RGBA
+	legendEntries        []ServerMapLegendEntry
+}
+
+const serverMapModelName = "ServerMap"
+
+func NewServerMap(server Server, markersCh <-chan ServerMapMarker) ServerMap {
+	size := server.Config().Coord().MapSize
+
+	return ServerMap{
+		server:    server,
+		size:      size,
+		markersCh: markersCh,
+		backgroundColor: color.RGBA{
+			A: 255,
+		},
+		scale:                1,
+		centerX:              size / 2,
+		centerY:              size / 2,
+		continentGrid:        true,
+		gridLineColor:        color.RGBA{R: 255, G: 255, B: 255, A: 255},
+		continentNumbers:     true,
+		continentNumberColor: color.RGBA{R: 255, G: 255, B: 255, A: 255},
+	}
+}
+
+func (m *ServerMap) Scale() float32 {
+	return m.scale
+}
+
+const (
+	serverMapMinScale = 1
+	serverMapMaxScale = 5
+)
+
+func (m *ServerMap) SetScale(scale float32) error {
+	if err := validateInRange(scale, serverMapMinScale, serverMapMaxScale); err != nil {
+		return ValidationError{
+			Model: serverMapModelName,
+			Field: "scale",
+			Err:   err,
+		}
+	}
+
+	m.scale = scale
+
+	return nil
+}
+
+func (m *ServerMap) BackgroundColor() color.RGBA {
+	return m.backgroundColor
+}
+
+func (m *ServerMap) SetBackgroundColor(backgroundColor color.RGBA) error {
+	m.backgroundColor = backgroundColor
+	return nil
+}
+
+func (m *ServerMap) CenterX() int {
+	return m.centerX
+}
+
+func (m *ServerMap) SetCenterX(centerX int) error {
+	m.centerX = centerX
+	return nil
+}
+
+func (m *ServerMap) CenterY() int {
+	return m.centerY
+}
+
+func (m *ServerMap) SetCenterY(centerY int) error {
+	m.centerY = centerY
+	return nil
+}
+
+func (m *ServerMap) ContinentGrid() bool {
+	return m.continentGrid
+}
+
+func (m *ServerMap) SetContinentGrid(continentGrid bool) error {
+	m.continentGrid = continentGrid
+	return nil
+}
+
+func (m *ServerMap) GridLineColor() color.RGBA {
+	return m.gridLineColor
+}
+
+func (m *ServerMap) SetGridLineColor(gridLineColor color.RGBA) error {
+	m.gridLineColor = gridLineColor
+	return nil
+}
+
+func (m *ServerMap) ContinentNumbers() bool {
+	return m.continentNumbers
+}
+
+func (m *ServerMap) SetContinentNumbers(continentNumbers bool) error {
+	m.continentNumbers = continentNumbers
+	return nil
+}
+
+func (m *ServerMap) ContinentNumberColor() color.RGBA {
+	return m.continentNumberColor
+}
+
+func (m *ServerMap) SetContinentNumberColor(continentNumberColor color.RGBA) error {
+	m.continentNumberColor = continentNumberColor
+	return nil
+}
+
+func (m *ServerMap) LegendEntries() []ServerMapLegendEntry {
+	return m.legendEntries
+}
+
+func (m *ServerMap) SetLegendEntries(legendEntries []ServerMapLegendEntry) error {
+	m.legendEntries = legendEntries
+	return nil
+}
+
+func (m *ServerMap) Generate(w io.Writer) error {
+	r := image.Rectangle{Max: image.Point{X: m.size, Y: m.size}}
+	imgHalfWidth := r.Dx() / 2
+	imgHalfHeight := r.Dy() / 2
+
+	img := image.NewRGBA(r)
+
+	draw.Draw(img, img.Bounds(), image.NewUniform(m.backgroundColor), image.Point{}, draw.Src)
+	m.drawContinentGrid(img)
+	m.drawMarkers(img)
+	m.drawContinentNumbers(img)
+	legend, err := m.generateLegend()
+	if err != nil {
+		return err
+	}
+
+	scaledImg := m.scaleImg(img)
+
+	final := image.NewRGBA(image.Rect(0, 0, r.Dx()+legend.Rect.Dx(), r.Dy()))
+	draw.Draw(final, scaledImg.Rect, scaledImg, image.Point{
+		X: int(float32(m.centerX)*m.scale) - imgHalfWidth,
+		Y: int(float32(m.centerY)*m.scale) - imgHalfHeight,
+	}, draw.Src)
+	draw.Draw(final, image.Rect(r.Dx(), 0, final.Rect.Dx(), final.Rect.Dy()), legend, image.Point{}, draw.Src)
+
+	if err = png.Encode(w, final); err != nil {
+		return fmt.Errorf("couldn't encode image: %w", err)
+	}
+
+	return nil
+}
+
+const serverMapContinentDx = 100
+
+func (m *ServerMap) drawContinentGrid(img *image.RGBA) {
+	if !m.continentGrid {
+		return
+	}
+
+	for y := serverMapContinentDx; y < m.size; y += serverMapContinentDx {
+		for x := range m.size {
+			img.Set(x, y, m.gridLineColor)
+			img.Set(y, x, m.gridLineColor)
+		}
+	}
+}
+
+const serverMapMarkerRectSideLength = 1
+
+func (m *ServerMap) drawMarkers(img *image.RGBA) {
+	for marker := range m.markersCh {
+		village := marker.Village()
+		x := village.X()
+		y := village.Y()
+		rect := image.Rect(x, y, x+serverMapMarkerRectSideLength, y+serverMapMarkerRectSideLength)
+		draw.Draw(img, rect, &image.Uniform{C: marker.color}, image.Point{}, draw.Over)
+	}
+}
+
+func (m *ServerMap) drawContinentNumbers(img *image.RGBA) {
+	if !m.continentNumbers {
+		return
+	}
+
+	continent := 0
+
+	d := &font.Drawer{
+		Dst:  img,
+		Src:  image.NewUniform(m.continentNumberColor),
+		Face: basicfont.Face7x13,
+	}
+
+	for y := serverMapContinentDx; y <= m.size; y += serverMapContinentDx {
+		for x := serverMapContinentDx; x <= m.size; x += serverMapContinentDx {
+			continentStr := strconv.Itoa(continent)
+
+			d.Dot = fixed.Point26_6{
+				X: fixed.I(x) - d.MeasureString(continentStr),
+				Y: fixed.I(y - 1),
+			}
+
+			d.DrawString(continentStr)
+
+			continent++
+		}
+	}
+}
+
+func (m *ServerMap) scaleImg(img *image.RGBA) *image.RGBA {
+	if m.scale == 1 {
+		return img
+	}
+
+	scaledSize := int(float32(m.size) * m.scale)
+	scaledImg := image.NewRGBA(image.Rect(0, 0, scaledSize, scaledSize))
+	draw.NearestNeighbor.Scale(scaledImg, scaledImg.Rect, img, img.Rect, draw.Over, nil)
+
+	return scaledImg
+}
+
+const (
+	serverMapLegendWidth           = 400
+	serverMapLegendPadding         = 10
+	serverMapColorWidth            = 40
+	serverMapSpaceColorText        = 10
+	serverMapLegendStringSeparator = " + "
+	serverMapLegendStringOverflow  = "..."
+	serverMapLegendMaxStringLength = 45
+)
+
+var ErrTooManyLegendEntries error = simpleError{
+	msg:  "too many legend entries",
+	typ:  ErrorTypeIncorrectInput,
+	code: "too-many-legend-entries",
+}
+
+func (m *ServerMap) generateLegend() (*image.RGBA, error) {
+	if len(m.legendEntries) == 0 {
+		return image.NewRGBA(image.Rectangle{}), nil
+	}
+
+	img := image.NewRGBA(image.Rectangle{Max: image.Point{X: serverMapLegendWidth, Y: m.size}})
+	d := &font.Drawer{
+		Dst:  img,
+		Src:  image.NewUniform(m.continentNumberColor),
+		Face: basicfont.Face7x13,
+	}
+	lineHeight := basicfont.Face7x13.Metrics().Ascent.Ceil() + basicfont.Face7x13.Metrics().Descent.Ceil()
+	lineMaxWidth := img.Rect.Dx() - serverMapLegendPadding*2 - serverMapColorWidth - serverMapSpaceColorText
+	offset := serverMapLegendPadding
+
+	for _, e := range m.legendEntries {
+		namesLen := len(e.Names())
+
+		currentWidth := 0
+		line := ""
+		var lines []string
+
+		for i, name := range e.Names() {
+			if len(name) > serverMapLegendMaxStringLength {
+				name = name[:serverMapLegendMaxStringLength-len(serverMapLegendStringOverflow)] + "..."
+			}
+
+			if i != namesLen-1 {
+				name += serverMapLegendStringSeparator
+			}
+
+			strWidth := d.MeasureString(name).Ceil()
+
+			if currentWidth+strWidth > lineMaxWidth {
+				lines = append(lines, line)
+				currentWidth = 0
+				line = ""
+			}
+
+			line += name
+			currentWidth += strWidth
+		}
+
+		if line != "" {
+			lines = append(lines, line)
+		}
+
+		yMin := offset + (len(lines) * lineHeight / 2) - lineHeight/2
+
+		draw.Draw(
+			img,
+			image.Rect(
+				serverMapLegendPadding,
+				yMin,
+				serverMapColorWidth+serverMapLegendPadding,
+				yMin+lineHeight,
+			),
+			image.NewUniform(e.Color()),
+			image.Point{},
+			draw.Src,
+		)
+
+		for i, l := range lines {
+			d.Dot = fixed.Point26_6{
+				X: fixed.I(serverMapColorWidth + serverMapLegendPadding + serverMapSpaceColorText),
+				Y: fixed.I(offset + (i+1)*lineHeight),
+			}
+			d.DrawString(l)
+		}
+
+		offset += (len(lines) * lineHeight) + serverMapLegendPadding
+
+		if offset > img.Bounds().Dy()-serverMapLegendPadding {
+			return nil, ErrTooManyLegendEntries
+		}
+	}
+
+	return img, nil
+}

internal/domain/server_map_test.go

@@ -0,0 +1,155 @@
+package domain_test
+
+import (
+	"image/color"
+	"io"
+	"testing"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/domain"
+	"gitea.dwysokinski.me/twhelp/core/internal/domain/domaintest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestServerMap_SetScale(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		scale float32
+	}
+
+	tests := []struct {
+		name        string
+		args        args
+		expectedErr error
+	}{
+		{
+			name: "OK",
+			args: args{
+				scale: 1,
+			},
+		},
+		{
+			name: "ERR: scale < 1",
+			args: args{
+				scale: 0.99,
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ServerMap",
+				Field: "scale",
+				Err: domain.MinGreaterEqualError[float32]{
+					Min:     1,
+					Current: 0.99,
+				},
+			},
+		},
+		{
+			name: "ERR: scale > 5",
+			args: args{
+				scale: 5.00001,
+			},
+			expectedErr: domain.ValidationError{
+				Model: "ServerMap",
+				Field: "scale",
+				Err: domain.MaxLessEqualError[float32]{
+					Max:     5,
+					Current: 5.00001,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewServerMap(domaintest.NewServer(t), make(chan domain.ServerMapMarker))
+
+			require.ErrorIs(t, params.SetScale(tt.args.scale), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.InDelta(t, tt.args.scale, params.Scale(), 0.001)
+		})
+	}
+}
+
+func TestServerMap_Generate(t *testing.T) {
+	t.Parallel()
+
+	t.Run("OK: default", func(t *testing.T) {
+		t.Parallel()
+
+		ch := make(chan domain.ServerMapMarker)
+
+		go func() {
+			defer close(ch)
+			for i := range 500 {
+				ch <- domain.NewServerMapMarker(domaintest.NewVillage(t, func(cfg *domaintest.VillageConfig) {
+					cfg.X = i
+					cfg.Y = i
+				}).Meta())
+			}
+		}()
+
+		m := domain.NewServerMap(domaintest.NewServer(t), ch)
+		require.NoError(t, m.Generate(io.Discard))
+	})
+
+	t.Run("OK: scale=2 legend", func(t *testing.T) {
+		t.Parallel()
+
+		ch := make(chan domain.ServerMapMarker)
+
+		go func() {
+			defer close(ch)
+			for i := range 500 {
+				ch <- domain.NewServerMapMarker(domaintest.NewVillage(t, func(cfg *domaintest.VillageConfig) {
+					cfg.X = i
+					cfg.Y = i
+				}).Meta())
+			}
+		}()
+
+		m := domain.NewServerMap(domaintest.NewServer(t), ch)
+		require.NoError(t, m.SetLegendEntries([]domain.ServerMapLegendEntry{
+			domain.NewServerMapLegendEntry(
+				color.RGBA{R: 255, G: 204, B: 229, A: 255},
+				"test22222^",
+				"test222",
+			),
+			domain.NewServerMapLegendEntry(
+				color.RGBA{R: 255, G: 255, B: 255, A: 255},
+				"test22222^",
+				"test2223",
+				"longstringlongstringlongstringlongstring",
+				"longstringlongstringlongstringlongstringlongstringlongstringlongstringlongstring",
+				"longstringlongstring2",
+			),
+		}))
+		require.NoError(t, m.SetScale(2))
+		require.NoError(t, m.Generate(io.Discard))
+	})
+
+	t.Run("OK: scale=2 centerX=250 centerY=250", func(t *testing.T) {
+		t.Parallel()
+
+		ch := make(chan domain.ServerMapMarker)
+
+		go func() {
+			defer close(ch)
+			for i := range 500 {
+				ch <- domain.NewServerMapMarker(domaintest.NewVillage(t, func(cfg *domaintest.VillageConfig) {
+					cfg.X = i
+					cfg.Y = i
+				}).Meta())
+			}
+		}()
+
+		m := domain.NewServerMap(domaintest.NewServer(t), ch)
+		require.NoError(t, m.SetCenterX(250))
+		require.NoError(t, m.SetCenterY(250))
+		require.NoError(t, m.SetScale(2))
+		require.NoError(t, m.Generate(io.Discard))
+	})
+}

internal/domain/server_snapshot.go

@@ -45,7 +45,7 @@ func UnmarshalServerSnapshotFromDatabase(
 	date time.Time,
 	createdAt time.Time,
 ) (ServerSnapshot, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return ServerSnapshot{}, ValidationError{
 			Model: serverSnapshotModelName,
 			Field: "id",
@@ -135,6 +135,13 @@ func (ss ServerSnapshot) CreatedAt() time.Time {
 	return ss.createdAt
 }
 
+func (ss ServerSnapshot) WithRelations(server ServerMeta) ServerSnapshotWithRelations {
+	return ServerSnapshotWithRelations{
+		snapshot: ss,
+		server:   server,
+	}
+}
+
 func (ss ServerSnapshot) ToCursor() (ServerSnapshotCursor, error) {
 	return NewServerSnapshotCursor(ss.id, ss.serverKey, ss.date)
 }
@@ -145,6 +152,25 @@ func (ss ServerSnapshot) IsZero() bool {
 
 type ServerSnapshots []ServerSnapshot
 
+type ServerSnapshotWithRelations struct {
+	snapshot ServerSnapshot
+	server   ServerMeta
+}
+
+func (ts ServerSnapshotWithRelations) ServerSnapshot() ServerSnapshot {
+	return ts.snapshot
+}
+
+func (ts ServerSnapshotWithRelations) Server() ServerMeta {
+	return ts.server
+}
+
+func (ts ServerSnapshotWithRelations) IsZero() bool {
+	return ts.snapshot.IsZero()
+}
+
+type ServerSnapshotsWithRelations []ServerSnapshotWithRelations
+
 type CreateServerSnapshotParams struct {
 	serverKey            string
 	numPlayers           int
@@ -279,7 +305,7 @@ type ServerSnapshotCursor struct {
 const serverSnapshotCursorModelName = "ServerSnapshotCursor"
 
 func NewServerSnapshotCursor(id int, serverKey string, date time.Time) (ServerSnapshotCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return ServerSnapshotCursor{}, ValidationError{
 			Model: serverSnapshotCursorModelName,
 			Field: "id",
@@ -510,7 +536,7 @@ func (params *ListServerSnapshotsParams) Limit() int {
 }
 
 func (params *ListServerSnapshotsParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, ServerSnapshotListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, ServerSnapshotListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listServerSnapshotsParamsModelName,
 			Field: "limit",
@@ -576,3 +602,57 @@ func (res ListServerSnapshotsResult) Self() ServerSnapshotCursor {
 func (res ListServerSnapshotsResult) Next() ServerSnapshotCursor {
 	return res.next
 }
+
+type ListServerSnapshotsWithRelationsResult struct {
+	snapshots ServerSnapshotsWithRelations
+	self      ServerSnapshotCursor
+	next      ServerSnapshotCursor
+}
+
+const listServerSnapshotsWithRelationsResultModelName = "ListServerSnapshotsWithRelationsResult"
+
+func NewListServerSnapshotsWithRelationsResult(
+	snapshots ServerSnapshotsWithRelations,
+	next ServerSnapshotWithRelations,
+) (ListServerSnapshotsWithRelationsResult, error) {
+	var err error
+	res := ListServerSnapshotsWithRelationsResult{
+		snapshots: snapshots,
+	}
+
+	if len(snapshots) > 0 {
+		res.self, err = snapshots[0].ServerSnapshot().ToCursor()
+		if err != nil {
+			return ListServerSnapshotsWithRelationsResult{}, ValidationError{
+				Model: listServerSnapshotsWithRelationsResultModelName,
+				Field: "self",
+				Err:   err,
+			}
+		}
+	}
+
+	if !next.IsZero() {
+		res.next, err = next.ServerSnapshot().ToCursor()
+		if err != nil {
+			return ListServerSnapshotsWithRelationsResult{}, ValidationError{
+				Model: listServerSnapshotsWithRelationsResultModelName,
+				Field: "next",
+				Err:   err,
+			}
+		}
+	}
+
+	return res, nil
+}
+
+func (res ListServerSnapshotsWithRelationsResult) ServerSnapshots() ServerSnapshotsWithRelations {
+	return res.snapshots
+}
+
+func (res ListServerSnapshotsWithRelationsResult) Self() ServerSnapshotCursor {
+	return res.self
+}
+
+func (res ListServerSnapshotsWithRelationsResult) Next() ServerSnapshotCursor {
+	return res.next
+}

internal/domain/server_snapshot_test.go

@@ -136,7 +136,7 @@ func TestNewServerSnapshotCursor(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ServerSnapshotCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -769,7 +769,7 @@ func TestListServerSnapshotsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListServerSnapshotsParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -783,7 +783,7 @@ func TestListServerSnapshotsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListServerSnapshotsParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.ServerSnapshotListMaxLimit,
 					Current: domain.ServerSnapshotListMaxLimit + 1,
 				},
@@ -852,3 +852,50 @@ func TestNewListServerSnapshotsResult(t *testing.T) {
 		assert.True(t, res.Next().IsZero())
 	})
 }
+
+func TestNewListServerSnapshotsWithRelationsResult(t *testing.T) {
+	t.Parallel()
+
+	snapshots := domain.ServerSnapshotsWithRelations{
+		domaintest.NewServerSnapshotWithRelations(t),
+		domaintest.NewServerSnapshotWithRelations(t),
+		domaintest.NewServerSnapshotWithRelations(t),
+	}
+	next := domaintest.NewServerSnapshotWithRelations(t)
+
+	t.Run("OK: with next", func(t *testing.T) {
+		t.Parallel()
+
+		res, err := domain.NewListServerSnapshotsWithRelationsResult(snapshots, next)
+		require.NoError(t, err)
+		assert.Equal(t, snapshots, res.ServerSnapshots())
+		assert.Equal(t, snapshots[0].ServerSnapshot().ID(), res.Self().ID())
+		assert.Equal(t, snapshots[0].ServerSnapshot().ServerKey(), res.Self().ServerKey())
+		assert.Equal(t, snapshots[0].ServerSnapshot().Date(), res.Self().Date())
+		assert.Equal(t, next.ServerSnapshot().ID(), res.Next().ID())
+		assert.Equal(t, next.ServerSnapshot().ServerKey(), res.Next().ServerKey())
+		assert.Equal(t, next.ServerSnapshot().Date(), res.Next().Date())
+	})
+
+	t.Run("OK: without next", func(t *testing.T) {
+		t.Parallel()
+
+		res, err := domain.NewListServerSnapshotsWithRelationsResult(snapshots, domain.ServerSnapshotWithRelations{})
+		require.NoError(t, err)
+		assert.Equal(t, snapshots, res.ServerSnapshots())
+		assert.Equal(t, snapshots[0].ServerSnapshot().ID(), res.Self().ID())
+		assert.Equal(t, snapshots[0].ServerSnapshot().ServerKey(), res.Self().ServerKey())
+		assert.Equal(t, snapshots[0].ServerSnapshot().Date(), res.Self().Date())
+		assert.True(t, res.Next().IsZero())
+	})
+
+	t.Run("OK: 0 snapshots", func(t *testing.T) {
+		t.Parallel()
+
+		res, err := domain.NewListServerSnapshotsWithRelationsResult(nil, domain.ServerSnapshotWithRelations{})
+		require.NoError(t, err)
+		assert.Zero(t, res.ServerSnapshots())
+		assert.True(t, res.Self().IsZero())
+		assert.True(t, res.Next().IsZero())
+	})
+}

internal/domain/server_test.go

@@ -201,7 +201,7 @@ func TestUpdateServerParams_SetNumTribes(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numTribes",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -264,7 +264,7 @@ func TestUpdateServerParams_SetNumActiveTribes(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numActiveTribes",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -327,7 +327,7 @@ func TestUpdateServerParams_SetNumInactiveTribes(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numInactiveTribes",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -390,7 +390,7 @@ func TestUpdateServerParams_SetNumPlayers(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numPlayers",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -453,7 +453,7 @@ func TestUpdateServerParams_SetNumActivePlayers(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numActivePlayers",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -516,7 +516,7 @@ func TestUpdateServerParams_SetNumInactivePlayers(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numInactivePlayers",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -579,7 +579,7 @@ func TestUpdateServerParams_SetNumVillages(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numVillages",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -642,7 +642,7 @@ func TestUpdateServerParams_SetNumPlayerVillages(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numPlayerVillages",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -705,7 +705,7 @@ func TestUpdateServerParams_SetNumBarbarianVillages(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numBarbarianVillages",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -768,7 +768,7 @@ func TestUpdateServerParams_SetNumBonusVillages(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "UpdateServerParams",
 				Field: "numBonusVillages",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -1207,7 +1207,7 @@ func TestListServersParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListServersParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1221,7 +1221,7 @@ func TestListServersParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListServersParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.ServerListMaxLimit,
 					Current: domain.ServerListMaxLimit + 1,
 				},

internal/domain/tribe.go

@@ -67,7 +67,7 @@ func UnmarshalTribeFromDatabase(
 	createdAt time.Time,
 	deletedAt time.Time,
 ) (Tribe, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return Tribe{}, ValidationError{
 			Model: tribeModelName,
 			Field: "id",
@@ -207,6 +207,7 @@ func (t Tribe) ToCursor() (TribeCursor, error) {
 		t.od.scoreDef,
 		t.od.scoreTotal,
 		t.points,
+		t.mostPoints,
 		t.dominance,
 		t.deletedAt,
 	)
@@ -295,7 +296,7 @@ const tribeMetaModelName = "TribeMeta"
 // It should be used only for unmarshalling from the database!
 // You can't use UnmarshalTribeMetaFromDatabase as constructor - It may put domain into the invalid state!
 func UnmarshalTribeMetaFromDatabase(id int, name string, tag string, rawProfileURL string) (TribeMeta, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return TribeMeta{}, ValidationError{
 			Model: tribeMetaModelName,
 			Field: "id",
@@ -472,6 +473,8 @@ const (
 	TribeSortODScoreTotalDESC
 	TribeSortPointsASC
 	TribeSortPointsDESC
+	TribeSortMostPointsASC
+	TribeSortMostPointsDESC
 	TribeSortDominanceASC
 	TribeSortDominanceDESC
 	TribeSortDeletedAtASC
@@ -510,6 +513,10 @@ func (s TribeSort) String() string {
 		return "points:ASC"
 	case TribeSortPointsDESC:
 		return "points:DESC"
+	case TribeSortMostPointsASC:
+		return "mostPoints:ASC"
+	case TribeSortMostPointsDESC:
+		return "mostPoints:DESC"
 	case TribeSortDominanceASC:
 		return "dominance:ASC"
 	case TribeSortDominanceDESC:
@@ -530,6 +537,7 @@ type TribeCursor struct {
 	odScoreDef   int
 	odScoreTotal int
 	points       int
+	mostPoints   int
 	dominance    float64
 	deletedAt    time.Time
 }
@@ -543,10 +551,11 @@ func NewTribeCursor(
 	odScoreDef int,
 	odScoreTotal int,
 	points int,
+	mostPoints int,
 	dominance float64,
 	deletedAt time.Time,
 ) (TribeCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return TribeCursor{}, ValidationError{
 			Model: tribeCursorModelName,
 			Field: "id",
@@ -562,7 +571,7 @@ func NewTribeCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreAtt, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreAtt, 0, math.MaxInt); err != nil {
 		return TribeCursor{}, ValidationError{
 			Model: tribeCursorModelName,
 			Field: "odScoreAtt",
@@ -570,7 +579,7 @@ func NewTribeCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreDef, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreDef, 0, math.MaxInt); err != nil {
 		return TribeCursor{}, ValidationError{
 			Model: tribeCursorModelName,
 			Field: "odScoreDef",
@@ -578,7 +587,7 @@ func NewTribeCursor(
 		}
 	}
 
-	if err := validateIntInRange(odScoreTotal, 0, math.MaxInt); err != nil {
+	if err := validateInRange(odScoreTotal, 0, math.MaxInt); err != nil {
 		return TribeCursor{}, ValidationError{
 			Model: tribeCursorModelName,
 			Field: "odScoreTotal",
@@ -586,7 +595,7 @@ func NewTribeCursor(
 		}
 	}
 
-	if err := validateIntInRange(points, 0, math.MaxInt); err != nil {
+	if err := validateInRange(points, 0, math.MaxInt); err != nil {
 		return TribeCursor{}, ValidationError{
 			Model: tribeCursorModelName,
 			Field: "points",
@@ -594,6 +603,14 @@ func NewTribeCursor(
 		}
 	}
 
+	if err := validateInRange(mostPoints, 0, math.MaxInt); err != nil {
+		return TribeCursor{}, ValidationError{
+			Model: tribeCursorModelName,
+			Field: "mostPoints",
+			Err:   err,
+		}
+	}
+
 	return TribeCursor{
 		id:           id,
 		serverKey:    serverKey,
@@ -601,6 +618,7 @@ func NewTribeCursor(
 		odScoreDef:   odScoreDef,
 		odScoreTotal: odScoreTotal,
 		points:       points,
+		mostPoints:   mostPoints,
 		dominance:    dominance,
 		deletedAt:    deletedAt,
 	}, nil
@@ -643,6 +661,11 @@ func decodeTribeCursor(encoded string) (TribeCursor, error) {
 		return TribeCursor{}, ErrInvalidCursor
 	}
 
+	mostPoints, err := m.int("mostPoints")
+	if err != nil {
+		return TribeCursor{}, ErrInvalidCursor
+	}
+
 	dominance, err := m.float64("dominance")
 	if err != nil {
 		return TribeCursor{}, ErrInvalidCursor
@@ -660,6 +683,7 @@ func decodeTribeCursor(encoded string) (TribeCursor, error) {
 		odScoreDef,
 		odScoreTotal,
 		points,
+		mostPoints,
 		dominance,
 		deletedAt,
 	)
@@ -694,6 +718,10 @@ func (tc TribeCursor) Points() int {
 	return tc.points
 }
 
+func (tc TribeCursor) MostPoints() int {
+	return tc.mostPoints
+}
+
 func (tc TribeCursor) Dominance() float64 {
 	return tc.dominance
 }
@@ -718,6 +746,7 @@ func (tc TribeCursor) Encode() string {
 		{"odScoreDef", tc.odScoreDef},
 		{"odScoreTotal", tc.odScoreTotal},
 		{"points", tc.points},
+		{"mostPoints", tc.mostPoints},
 		{"dominance", tc.dominance},
 		{"deletedAt", tc.deletedAt},
 	})
@@ -754,7 +783,7 @@ func (params *ListTribesParams) IDs() []int {
 
 func (params *ListTribesParams) SetIDs(ids []int) error {
 	for i, id := range ids {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listTribesParamsModelName,
 				Field: "ids",
@@ -905,7 +934,7 @@ func (params *ListTribesParams) Limit() int {
 }
 
 func (params *ListTribesParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, TribeListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, TribeListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listTribesParamsModelName,
 			Field: "limit",

internal/domain/tribe_change.go

@@ -31,7 +31,7 @@ func UnmarshalTribeChangeFromDatabase(
 	newTribeID int,
 	createdAt time.Time,
 ) (TribeChange, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return TribeChange{}, ValidationError{
 			Model: tribeChangeModelName,
 			Field: "id",
@@ -156,7 +156,7 @@ func NewCreateTribeChangeParams(
 		}
 	}
 
-	if err := validateIntInRange(playerID, 1, math.MaxInt); err != nil {
+	if err := validateInRange(playerID, 1, math.MaxInt); err != nil {
 		return CreateTribeChangeParams{}, ValidationError{
 			Model: createTribeChangeParamsModelName,
 			Field: "playerID",
@@ -164,7 +164,7 @@ func NewCreateTribeChangeParams(
 		}
 	}
 
-	if err := validateIntInRange(oldTribeID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(oldTribeID, 0, math.MaxInt); err != nil {
 		return CreateTribeChangeParams{}, ValidationError{
 			Model: createTribeChangeParamsModelName,
 			Field: "oldTribeID",
@@ -172,7 +172,7 @@ func NewCreateTribeChangeParams(
 		}
 	}
 
-	if err := validateIntInRange(newTribeID, 0, math.MaxInt); err != nil {
+	if err := validateInRange(newTribeID, 0, math.MaxInt); err != nil {
 		return CreateTribeChangeParams{}, ValidationError{
 			Model: createTribeChangeParamsModelName,
 			Field: "newTribeID",
@@ -297,7 +297,7 @@ type TribeChangeCursor struct {
 const tribeChangeCursorModelName = "TribeChangeCursor"
 
 func NewTribeChangeCursor(id int, serverKey string, createdAt time.Time) (TribeChangeCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return TribeChangeCursor{}, ValidationError{
 			Model: tribeChangeCursorModelName,
 			Field: "id",
@@ -436,7 +436,7 @@ func (params *ListTribeChangesParams) PlayerIDs() []int {
 
 func (params *ListTribeChangesParams) SetPlayerIDs(playerIDs []int) error {
 	for i, id := range playerIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listTribeChangesParamsModelName,
 				Field: "playerIDs",
@@ -457,7 +457,7 @@ func (params *ListTribeChangesParams) TribeIDs() []int {
 
 func (params *ListTribeChangesParams) SetTribeIDs(tribeIDs []int) error {
 	for i, id := range tribeIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listTribeChangesParamsModelName,
 				Field: "tribeIDs",
@@ -542,7 +542,7 @@ func (params *ListTribeChangesParams) Limit() int {
 }
 
 func (params *ListTribeChangesParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, TribeChangeListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, TribeChangeListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listTribeChangesParamsModelName,
 			Field: "limit",

internal/domain/tribe_change_test.go

@@ -53,7 +53,7 @@ func TestNewCreateTribeChangeParams(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "CreateTribeChangeParams",
 				Field: "playerID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -70,7 +70,7 @@ func TestNewCreateTribeChangeParams(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "CreateTribeChangeParams",
 				Field: "oldTribeID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -87,7 +87,7 @@ func TestNewCreateTribeChangeParams(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "CreateTribeChangeParams",
 				Field: "newTribeID",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -318,7 +318,7 @@ func TestNewTribeChangeCursor(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "TribeChangeCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -453,7 +453,7 @@ func TestListTribeChangesParams_SetPlayerIDs(t *testing.T) {
 				Model: "ListTribeChangesParams",
 				Field: "playerIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -513,7 +513,7 @@ func TestListTribeChangesParams_SetTribeIDs(t *testing.T) {
 				Model: "ListTribeChangesParams",
 				Field: "tribeIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1071,7 +1071,7 @@ func TestListTribeChangesParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListTribeChangesParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1085,7 +1085,7 @@ func TestListTribeChangesParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListTribeChangesParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.TribeChangeListMaxLimit,
 					Current: domain.TribeChangeListMaxLimit + 1,
 				},

internal/domain/tribe_snapshot.go

@@ -43,7 +43,7 @@ func UnmarshalTribeSnapshotFromDatabase(
 	date time.Time,
 	createdAt time.Time,
 ) (TribeSnapshot, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return TribeSnapshot{}, ValidationError{
 			Model: tribeSnapshotModelName,
 			Field: "id",
@@ -51,7 +51,7 @@ func UnmarshalTribeSnapshotFromDatabase(
 		}
 	}
 
-	if err := validateIntInRange(tribeID, 1, math.MaxInt); err != nil {
+	if err := validateInRange(tribeID, 1, math.MaxInt); err != nil {
 		return TribeSnapshot{}, ValidationError{
 			Model: tribeSnapshotModelName,
 			Field: "tribeID",
@@ -295,7 +295,7 @@ type TribeSnapshotCursor struct {
 const tribeSnapshotCursorModelName = "TribeSnapshotCursor"
 
 func NewTribeSnapshotCursor(id int, serverKey string, date time.Time) (TribeSnapshotCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return TribeSnapshotCursor{}, ValidationError{
 			Model: tribeSnapshotCursorModelName,
 			Field: "id",
@@ -430,7 +430,7 @@ func (params *ListTribeSnapshotsParams) TribeIDs() []int {
 
 func (params *ListTribeSnapshotsParams) SetTribeIDs(tribeIDs []int) error {
 	for i, id := range tribeIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listTribeSnapshotsParamsModelName,
 				Field: "tribeIDs",
@@ -548,7 +548,7 @@ func (params *ListTribeSnapshotsParams) Limit() int {
 }
 
 func (params *ListTribeSnapshotsParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, TribeSnapshotListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, TribeSnapshotListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listTribeSnapshotsParamsModelName,
 			Field: "limit",

internal/domain/tribe_snapshot_test.go

@@ -149,7 +149,7 @@ func TestNewTribeSnapshotCursor(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "TribeSnapshotCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -284,7 +284,7 @@ func TestListTribeSnapshotsParams_SetTribeIDs(t *testing.T) {
 				Model: "ListTribeSnapshotsParams",
 				Field: "tribeIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -842,7 +842,7 @@ func TestListTribeSnapshotsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListTribeSnapshotsParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -856,7 +856,7 @@ func TestListTribeSnapshotsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListTribeSnapshotsParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.TribeSnapshotListMaxLimit,
 					Current: domain.TribeSnapshotListMaxLimit + 1,
 				},

internal/domain/tribe_test.go

@@ -255,6 +255,13 @@ func TestTribeSort_IsInConflict(t *testing.T) {
 			},
 			expectedRes: true,
 		},
+		{
+			name: "OK: mostPoints:ASC mostPoints:DESC",
+			args: args{
+				sorts: [2]domain.TribeSort{domain.TribeSortMostPointsASC, domain.TribeSortMostPointsDESC},
+			},
+			expectedRes: true,
+		},
 		{
 			name: "OK: dominance:ASC dominance:DESC",
 			args: args{
@@ -292,6 +299,7 @@ func TestNewTribeCursor(t *testing.T) {
 		odScoreDef   int
 		odScoreTotal int
 		points       int
+		mostPoints   int
 		dominance    float64
 		deletedAt    time.Time
 	}
@@ -312,6 +320,7 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   validTribeCursor.ODScoreDef(),
 				odScoreTotal: validTribeCursor.ODScoreTotal(),
 				points:       validTribeCursor.Points(),
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
@@ -326,13 +335,14 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   validTribeCursor.ODScoreDef(),
 				odScoreTotal: validTribeCursor.ODScoreTotal(),
 				points:       validTribeCursor.Points(),
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "TribeCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -347,13 +357,14 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   validTribeCursor.ODScoreDef(),
 				odScoreTotal: validTribeCursor.ODScoreTotal(),
 				points:       validTribeCursor.Points(),
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "TribeCursor",
 				Field: "odScoreAtt",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -368,13 +379,14 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   -1,
 				odScoreTotal: validTribeCursor.ODScoreTotal(),
 				points:       validTribeCursor.Points(),
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "TribeCursor",
 				Field: "odScoreDef",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -389,13 +401,14 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   validTribeCursor.ODScoreDef(),
 				odScoreTotal: -1,
 				points:       validTribeCursor.Points(),
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "TribeCursor",
 				Field: "odScoreTotal",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -410,13 +423,36 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   validTribeCursor.ODScoreDef(),
 				odScoreTotal: validTribeCursor.ODScoreTotal(),
 				points:       -1,
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
 			expectedErr: domain.ValidationError{
 				Model: "TribeCursor",
 				Field: "points",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
+					Min:     0,
+					Current: -1,
+				},
+			},
+		},
+		{
+			name: "ERR: points < 0",
+			args: args{
+				id:           validTribeCursor.ID(),
+				serverKey:    validTribeCursor.ServerKey(),
+				odScoreAtt:   validTribeCursor.ODScoreAtt(),
+				odScoreDef:   validTribeCursor.ODScoreDef(),
+				odScoreTotal: validTribeCursor.ODScoreTotal(),
+				points:       validTribeCursor.Points(),
+				mostPoints:   -1,
+				dominance:    validTribeCursor.Dominance(),
+				deletedAt:    validTribeCursor.DeletedAt(),
+			},
+			expectedErr: domain.ValidationError{
+				Model: "TribeCursor",
+				Field: "mostPoints",
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     0,
 					Current: -1,
 				},
@@ -434,6 +470,7 @@ func TestNewTribeCursor(t *testing.T) {
 				odScoreDef:   validTribeCursor.ODScoreDef(),
 				odScoreTotal: validTribeCursor.ODScoreTotal(),
 				points:       validTribeCursor.Points(),
+				mostPoints:   validTribeCursor.MostPoints(),
 				dominance:    validTribeCursor.Dominance(),
 				deletedAt:    validTribeCursor.DeletedAt(),
 			},
@@ -456,6 +493,7 @@ func TestNewTribeCursor(t *testing.T) {
 				tt.args.odScoreDef,
 				tt.args.odScoreTotal,
 				tt.args.points,
+				tt.args.mostPoints,
 				tt.args.dominance,
 				tt.args.deletedAt,
 			)
@@ -469,6 +507,7 @@ func TestNewTribeCursor(t *testing.T) {
 			assert.Equal(t, tt.args.odScoreDef, tc.ODScoreDef())
 			assert.Equal(t, tt.args.odScoreTotal, tc.ODScoreTotal())
 			assert.Equal(t, tt.args.points, tc.Points())
+			assert.Equal(t, tt.args.mostPoints, tc.MostPoints())
 			assert.InDelta(t, tt.args.dominance, tc.Dominance(), 0.001)
 			assert.Equal(t, tt.args.deletedAt, tc.DeletedAt())
 			assert.NotEmpty(t, tc.Encode())
@@ -513,7 +552,7 @@ func TestListTribesParams_SetIDs(t *testing.T) {
 				Model: "ListTribesParams",
 				Field: "ids",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1125,7 +1164,7 @@ func TestListTribesParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListTribesParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -1139,7 +1178,7 @@ func TestListTribesParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListTribesParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.TribeListMaxLimit,
 					Current: domain.TribeListMaxLimit + 1,
 				},

internal/domain/validation.go

@@ -122,56 +122,56 @@ func (e SliceElementValidationError) Unwrap() error {
 	return e.Err
 }
 
-type MinGreaterEqualError struct {
-	Min     int
-	Current int
+type MinGreaterEqualError[T float32 | float64 | int] struct {
+	Min     T
+	Current T
 }
 
-var _ ErrorWithParams = MinGreaterEqualError{}
+var _ ErrorWithParams = MinGreaterEqualError[int]{}
 
-func (e MinGreaterEqualError) Error() string {
-	return fmt.Sprintf("must be no less than %d (current: %d)", e.Min, e.Current)
+func (e MinGreaterEqualError[T]) Error() string {
+	return fmt.Sprintf("must be no less than %v (current: %v)", e.Min, e.Current)
 }
 
-func (e MinGreaterEqualError) Type() ErrorType {
+func (e MinGreaterEqualError[T]) Type() ErrorType {
 	return ErrorTypeIncorrectInput
 }
 
 const errorCodeMinGreaterEqual = "min-greater-equal"
 
-func (e MinGreaterEqualError) Code() string {
+func (e MinGreaterEqualError[T]) Code() string {
 	return errorCodeMinGreaterEqual
 }
 
-func (e MinGreaterEqualError) Params() map[string]any {
+func (e MinGreaterEqualError[T]) Params() map[string]any {
 	return map[string]any{
 		"Min":     e.Min,
 		"Current": e.Current,
 	}
 }
 
-type MaxLessEqualError struct {
-	Max     int
-	Current int
+type MaxLessEqualError[T float32 | float64 | int] struct {
+	Max     T
+	Current T
 }
 
-var _ ErrorWithParams = MaxLessEqualError{}
+var _ ErrorWithParams = MaxLessEqualError[int]{}
 
-func (e MaxLessEqualError) Error() string {
-	return fmt.Sprintf("must be no greater than %d (current: %d)", e.Max, e.Current)
+func (e MaxLessEqualError[T]) Error() string {
+	return fmt.Sprintf("must be no greater than %v (current: %v)", e.Max, e.Current)
 }
 
-func (e MaxLessEqualError) Type() ErrorType {
+func (e MaxLessEqualError[T]) Type() ErrorType {
 	return ErrorTypeIncorrectInput
 }
 
 const errorCodeMaxLessEqual = "max-less-equal"
 
-func (e MaxLessEqualError) Code() string {
+func (e MaxLessEqualError[T]) Code() string {
 	return errorCodeMaxLessEqual
 }
 
-func (e MaxLessEqualError) Params() map[string]any {
+func (e MaxLessEqualError[T]) Params() map[string]any {
 	return map[string]any{
 		"Max":     e.Max,
 		"Current": e.Current,
@@ -356,16 +356,16 @@ func validateServerKey(key string) error {
 	return validateStringLen(key, serverKeyMinLength, serverKeyMaxLength)
 }
 
-func validateIntInRange(current, min, max int) error {
+func validateInRange[T float32 | float64 | int](current, min, max T) error {
 	if current < min {
-		return MinGreaterEqualError{
+		return MinGreaterEqualError[T]{
 			Min:     min,
 			Current: current,
 		}
 	}
 
 	if current > max {
-		return MaxLessEqualError{
+		return MaxLessEqualError[T]{
 			Max:     max,
 			Current: current,
 		}

internal/domain/version.go

@@ -269,7 +269,7 @@ func (params *ListVersionsParams) Limit() int {
 }
 
 func (params *ListVersionsParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, VersionListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, VersionListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listVersionsParamsModelName,
 			Field: "limit",

internal/domain/version_test.go

@@ -324,7 +324,7 @@ func TestListVersionsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListVersionsParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -338,7 +338,7 @@ func TestListVersionsParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListVersionsParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.VersionListMaxLimit,
 					Current: domain.VersionListMaxLimit + 1,
 				},

internal/domain/village.go

@@ -49,7 +49,7 @@ func UnmarshalVillageFromDatabase(
 	rawProfileURL string,
 	createdAt time.Time,
 ) (Village, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return Village{}, ValidationError{
 			Model: villageModelName,
 			Field: "id",
@@ -263,7 +263,7 @@ func UnmarshalVillageMetaFromDatabase(
 	continent string,
 	rawProfileURL string,
 ) (VillageMeta, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return VillageMeta{}, ValidationError{
 			Model: villageMetaModelName,
 			Field: "id",
@@ -423,7 +423,7 @@ type VillageCursor struct {
 const villageCursorModelName = "VillageCursor"
 
 func NewVillageCursor(id int, serverKey string) (VillageCursor, error) {
-	if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+	if err := validateInRange(id, 1, math.MaxInt); err != nil {
 		return VillageCursor{}, ValidationError{
 			Model: villageCursorModelName,
 			Field: "id",
@@ -528,7 +528,7 @@ func (params *ListVillagesParams) IDs() []int {
 
 func (params *ListVillagesParams) SetIDs(ids []int) error {
 	for i, id := range ids {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listVillagesParamsModelName,
 				Field: "ids",
@@ -623,7 +623,7 @@ func (params *ListVillagesParams) PlayerIDs() []int {
 
 func (params *ListVillagesParams) SetPlayerIDs(playerIDs []int) error {
 	for i, id := range playerIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listVillagesParamsModelName,
 				Field: "playerIDs",
@@ -644,7 +644,7 @@ func (params *ListVillagesParams) TribeIDs() []int {
 
 func (params *ListVillagesParams) SetTribeIDs(tribeIDs []int) error {
 	for i, id := range tribeIDs {
-		if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
+		if err := validateInRange(id, 1, math.MaxInt); err != nil {
 			return SliceElementValidationError{
 				Model: listVillagesParamsModelName,
 				Field: "tribeIDs",
@@ -711,7 +711,7 @@ func (params *ListVillagesParams) Limit() int {
 }
 
 func (params *ListVillagesParams) SetLimit(limit int) error {
-	if err := validateIntInRange(limit, 1, VillageListMaxLimit); err != nil {
+	if err := validateInRange(limit, 1, VillageListMaxLimit); err != nil {
 		return ValidationError{
 			Model: listVillagesParamsModelName,
 			Field: "limit",

internal/domain/village_test.go

@@ -181,7 +181,7 @@ func TestNewVillageCursor(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "VillageCursor",
 				Field: "id",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -260,7 +260,7 @@ func TestListVillagesParams_SetIDs(t *testing.T) {
 				Model: "ListVillagesParams",
 				Field: "ids",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -545,7 +545,7 @@ func TestListVillagesParams_SetPlayerIDs(t *testing.T) {
 				Model: "ListVillagesParams",
 				Field: "playerIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -605,7 +605,7 @@ func TestListVillagesParams_SetTribeIDs(t *testing.T) {
 				Model: "ListVillagesParams",
 				Field: "tribeIDs",
 				Index: 3,
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -814,7 +814,7 @@ func TestListVillagesParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListVillagesParams",
 				Field: "limit",
-				Err: domain.MinGreaterEqualError{
+				Err: domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: 0,
 				},
@@ -828,7 +828,7 @@ func TestListVillagesParams_SetLimit(t *testing.T) {
 			expectedErr: domain.ValidationError{
 				Model: "ListVillagesParams",
 				Field: "limit",
-				Err: domain.MaxLessEqualError{
+				Err: domain.MaxLessEqualError[int]{
 					Max:     domain.VillageListMaxLimit,
 					Current: domain.VillageListMaxLimit + 1,
 				},

internal/port/handler_http_api.go

@@ -20,6 +20,7 @@ type apiHTTPHandler struct {
 	villageSvc        *app.VillageService
 	ennoblementSvc    *app.EnnoblementService
 	tribeChangeSvc    *app.TribeChangeService
+	serverSnapshotSvc *app.ServerSnapshotService
 	tribeSnapshotSvc  *app.TribeSnapshotService
 	playerSnapshotSvc *app.PlayerSnapshotService
 	errorRenderer     apiErrorRenderer
@@ -40,6 +41,7 @@ func NewAPIHTTPHandler(
 	villageSvc *app.VillageService,
 	ennoblementSvc *app.EnnoblementService,
 	tribeChangeSvc *app.TribeChangeService,
+	serverSnapshotSvc *app.ServerSnapshotService,
 	tribeSnapshotSvc *app.TribeSnapshotService,
 	playerSnapshotSvc *app.PlayerSnapshotService,
 	opts ...APIHTTPHandlerOption,
@@ -54,6 +56,7 @@ func NewAPIHTTPHandler(
 		villageSvc:        villageSvc,
 		ennoblementSvc:    ennoblementSvc,
 		tribeChangeSvc:    tribeChangeSvc,
+		serverSnapshotSvc: serverSnapshotSvc,
 		tribeSnapshotSvc:  tribeSnapshotSvc,
 		playerSnapshotSvc: playerSnapshotSvc,
 		openAPISchema: sync.OnceValues(func() (*openapi3.T, error) {

internal/port/handler_http_api_ennoblement_test.go

@@ -258,7 +258,7 @@ func TestListEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -294,7 +294,7 @@ func TestListEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.EnnoblementListMaxLimit,
 					Current: limit,
 				}
@@ -866,7 +866,7 @@ func TestListPlayerEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -902,7 +902,7 @@ func TestListPlayerEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.EnnoblementListMaxLimit,
 					Current: limit,
 				}
@@ -1532,7 +1532,7 @@ func TestListTribeEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -1568,7 +1568,7 @@ func TestListTribeEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.EnnoblementListMaxLimit,
 					Current: limit,
 				}
@@ -2185,7 +2185,7 @@ func TestListVillageEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -2221,7 +2221,7 @@ func TestListVillageEnnoblements(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.EnnoblementListMaxLimit,
 					Current: limit,
 				}

internal/port/handler_http_api_player.go

@@ -24,6 +24,8 @@ var apiPlayerSortAllowedValues = []domain.PlayerSort{
 	domain.PlayerSortODScoreTotalDESC,
 	domain.PlayerSortPointsASC,
 	domain.PlayerSortPointsDESC,
+	domain.PlayerSortMostPointsASC,
+	domain.PlayerSortMostPointsDESC,
 	domain.PlayerSortDeletedAtASC,
 	domain.PlayerSortDeletedAtDESC,
 }

internal/port/handler_http_api_player_snapshot_test.go

@@ -192,7 +192,7 @@ func TestListPlayerPlayerSnapshots(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -228,7 +228,7 @@ func TestListPlayerPlayerSnapshots(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.PlayerSnapshotListMaxLimit,
 					Current: limit,
 				}

internal/port/handler_http_api_player_test.go

@@ -181,6 +181,33 @@ func TestListVersionPlayers(t *testing.T) {
 				}))
 			},
 		},
+		{
+			name: "OK: sort=[mostPoints:DESC]",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("sort", "mostPoints:DESC")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListPlayersWithServersResponse](t, resp.Body)
+				assert.Zero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.PlayerWithServer) int {
+					return cmp.Or(
+						cmp.Compare(a.Server.Key, b.Server.Key),
+						cmp.Compare(a.MostPoints, b.MostPoints)*-1,
+						cmp.Compare(a.Id, b.Id),
+					)
+				}))
+			},
+		},
 		{
 			name: "OK: name",
 			reqModifier: func(t *testing.T, req *http.Request) {
@@ -343,7 +370,7 @@ func TestListVersionPlayers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -379,7 +406,7 @@ func TestListVersionPlayers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.PlayerListMaxLimit,
 					Current: limit,
 				}
@@ -653,7 +680,7 @@ func TestListVersionPlayers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				id, err := strconv.Atoi(req.URL.Query().Get("id"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: id,
 				}
@@ -1023,6 +1050,32 @@ func TestListServerPlayers(t *testing.T) {
 				}))
 			},
 		},
+		{
+			name: "OK: sort=[mostPoints:DESC]",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("sort", "mostPoints:DESC")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListPlayersWithServersResponse](t, resp.Body)
+				assert.Zero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.PlayerWithServer) int {
+					return cmp.Or(
+						cmp.Compare(a.MostPoints, b.MostPoints)*-1,
+						cmp.Compare(a.Id, b.Id),
+					)
+				}))
+			},
+		},
 		{
 			name: "OK: name",
 			reqModifier: func(t *testing.T, req *http.Request) {
@@ -1185,7 +1238,7 @@ func TestListServerPlayers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -1221,7 +1274,7 @@ func TestListServerPlayers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.PlayerListMaxLimit,
 					Current: limit,
 				}
@@ -1495,7 +1548,7 @@ func TestListServerPlayers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				id, err := strconv.Atoi(req.URL.Query().Get("id"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: id,
 				}
@@ -1863,6 +1916,32 @@ func TestListTribeMembers(t *testing.T) {
 				}))
 			},
 		},
+		{
+			name: "OK: sort=[mostPoints:DESC]",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("sort", "mostPoints:DESC")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListPlayersWithServersResponse](t, resp.Body)
+				assert.Zero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.PlayerWithServer) int {
+					return cmp.Or(
+						cmp.Compare(a.MostPoints, b.MostPoints)*-1,
+						cmp.Compare(a.Id, b.Id),
+					)
+				}))
+			},
+		},
 		{
 			name: "ERR: limit is not an integer",
 			reqModifier: func(t *testing.T, req *http.Request) {
@@ -1909,7 +1988,7 @@ func TestListTribeMembers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -1945,7 +2024,7 @@ func TestListTribeMembers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.PlayerListMaxLimit,
 					Current: limit,
 				}
@@ -2339,7 +2418,7 @@ func TestGetPlayer(t *testing.T) {
 				require.Len(t, pathSegments, 8)
 				id, err := strconv.Atoi(pathSegments[7])
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: id,
 				}

internal/port/handler_http_api_server_snapshot.go

@@ -0,0 +1,96 @@
+package port
+
+import (
+	"net/http"
+	"strconv"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/domain"
+	"gitea.dwysokinski.me/twhelp/core/internal/port/internal/apimodel"
+)
+
+const apiServerSnapshotSortMaxLength = 1
+
+var apiServerSnapshotSortAllowedValues = []domain.ServerSnapshotSort{
+	domain.ServerSnapshotSortDateASC,
+	domain.ServerSnapshotSortDateDESC,
+}
+
+//nolint:gocyclo
+func (h *apiHTTPHandler) ListServerServerSnapshots(
+	w http.ResponseWriter,
+	r *http.Request,
+	_ apimodel.VersionCodePathParam,
+	serverKey apimodel.ServerKeyPathParam,
+	params apimodel.ListServerServerSnapshotsParams,
+) {
+	domainParams := domain.NewListServerSnapshotsParams()
+
+	if err := domainParams.SetSort([]domain.ServerSnapshotSort{domain.ServerSnapshotSortIDASC}); err != nil {
+		h.errorRenderer.withErrorPathFormatter(formatListServerSnapshotsErrorPath).render(w, r, err)
+		return
+	}
+
+	if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {
+		h.errorRenderer.withErrorPathFormatter(formatListServerSnapshotsErrorPath).render(w, r, err)
+		return
+	}
+
+	if params.Sort != nil {
+		if err := domainParams.PrependSortString(
+			*params.Sort,
+			apiServerSnapshotSortAllowedValues,
+			apiServerSnapshotSortMaxLength,
+		); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListServerSnapshotsErrorPath).render(w, r, err)
+			return
+		}
+	} else {
+		if err := domainParams.PrependSort([]domain.ServerSnapshotSort{domain.ServerSnapshotSortDateASC}); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListServerSnapshotsErrorPath).render(w, r, err)
+			return
+		}
+	}
+
+	if params.Limit != nil {
+		if err := domainParams.SetLimit(*params.Limit); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListServerSnapshotsErrorPath).render(w, r, err)
+			return
+		}
+	}
+
+	if params.Cursor != nil {
+		if err := domainParams.SetEncodedCursor(*params.Cursor); err != nil {
+			h.errorRenderer.withErrorPathFormatter(formatListServerSnapshotsErrorPath).render(w, r, err)
+			return
+		}
+	}
+
+	res, err := h.serverSnapshotSvc.ListWithRelations(r.Context(), domainParams)
+	if err != nil {
+		h.errorRenderer.render(w, r, err)
+		return
+	}
+
+	renderJSON(w, r, http.StatusOK, apimodel.NewListServerSnapshotsResponse(res))
+}
+
+func formatListServerSnapshotsErrorPath(segments []domain.ErrorPathSegment) []string {
+	if segments[0].Model != "ListServerSnapshotsParams" {
+		return nil
+	}
+
+	switch segments[0].Field {
+	case "cursor":
+		return []string{"$query", "cursor"}
+	case "limit":
+		return []string{"$query", "limit"}
+	case "sort":
+		path := []string{"$query", "sort"}
+		if segments[0].Index >= 0 {
+			path = append(path, strconv.Itoa(segments[0].Index))
+		}
+		return path
+	default:
+		return nil
+	}
+}

internal/port/handler_http_api_server_snapshot_test.go

@@ -0,0 +1,542 @@
+package port_test
+
+import (
+	"cmp"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"slices"
+	"strconv"
+	"strings"
+	"testing"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/domain"
+	"gitea.dwysokinski.me/twhelp/core/internal/domain/domaintest"
+	"gitea.dwysokinski.me/twhelp/core/internal/port/internal/apimodel"
+	"github.com/brianvoe/gofakeit/v7"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const endpointListServerServerSnapshots = "/v2/versions/%s/servers/%s/snapshots"
+
+func TestListServerServerSnapshots(t *testing.T) {
+	t.Parallel()
+
+	handler := newAPIHTTPHandler(t)
+	sss := getAllServerSnapshots(t, handler)
+	var server serverWithVersion
+
+	sssGroupedByServerKey := make(map[string][]serverSnapshotWithServer)
+	for _, ss := range sss {
+		key := ss.Server.Key
+		sssGroupedByServerKey[key] = append(sssGroupedByServerKey[key], ss)
+	}
+	currentMax := -1
+	for _, grouped := range sssGroupedByServerKey {
+		if l := len(grouped); l > currentMax && l > 0 {
+			currentMax = l
+			server = grouped[0].Server
+		}
+	}
+
+	tests := []struct {
+		name        string
+		reqModifier func(t *testing.T, req *http.Request)
+		assertResp  func(t *testing.T, req *http.Request, resp *http.Response)
+	}{
+		{
+			name: "OK: without params",
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListServerSnapshotsResponse](t, resp.Body)
+				assert.Zero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.ServerSnapshot) int {
+					return cmp.Or(
+						a.Date.Compare(b.Date.Time),
+						cmp.Compare(a.Id, b.Id),
+					)
+				}))
+			},
+		},
+		{
+			name: "OK: limit=1",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("limit", "1")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListServerSnapshotsResponse](t, resp.Body)
+				assert.NotZero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
+				require.NoError(t, err)
+				assert.Len(t, body.Data, limit)
+			},
+		},
+		{
+			name: "OK: limit=1 cursor",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+
+				q := req.URL.Query()
+				q.Set("limit", "1")
+				req.URL.RawQuery = q.Encode()
+
+				resp := doCustomRequest(handler, req.Clone(req.Context()))
+				defer resp.Body.Close()
+				body := decodeJSON[apimodel.ListServerSnapshotsResponse](t, resp.Body)
+				require.NotEmpty(t, body.Cursor.Next)
+
+				q.Set("cursor", body.Cursor.Next)
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListServerSnapshotsResponse](t, resp.Body)
+				assert.Equal(t, req.URL.Query().Get("cursor"), body.Cursor.Self)
+				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
+				require.NoError(t, err)
+				assert.Len(t, body.Data, limit)
+			},
+		},
+		{
+			name: "OK: sort=[date:DESC]",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("sort", "date:DESC")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListServerSnapshotsResponse](t, resp.Body)
+				assert.Zero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.ServerSnapshot) int {
+					return cmp.Or(
+						a.Date.Compare(b.Date.Time)*-1,
+						cmp.Compare(a.Id, b.Id),
+					)
+				}))
+			},
+		},
+		{
+			name: "ERR: limit is not an integer",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("limit", "asd")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code: "invalid-param-format",
+							Message: fmt.Sprintf(
+								"error binding string parameter: strconv.ParseInt: parsing \"%s\": invalid syntax",
+								req.URL.Query().Get("limit"),
+							),
+							Path: []string{"$query", "limit"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: limit < 1",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("limit", "0")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
+				require.NoError(t, err)
+				domainErr := domain.MinGreaterEqualError[int]{
+					Min:     1,
+					Current: limit,
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"current": float64(domainErr.Current),
+								"min":     float64(domainErr.Min),
+							},
+							Path: []string{"$query", "limit"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: fmt.Sprintf("ERR: limit > %d", domain.ServerSnapshotListMaxLimit),
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("limit", strconv.Itoa(domain.ServerSnapshotListMaxLimit+1))
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
+				require.NoError(t, err)
+				domainErr := domain.MaxLessEqualError[int]{
+					Max:     domain.ServerSnapshotListMaxLimit,
+					Current: limit,
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"current": float64(domainErr.Current),
+								"max":     float64(domainErr.Max),
+							},
+							Path: []string{"$query", "limit"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: len(cursor) < 1",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("cursor", "")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				domainErr := domain.LenOutOfRangeError{
+					Min:     1,
+					Max:     1000,
+					Current: len(req.URL.Query().Get("cursor")),
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"current": float64(domainErr.Current),
+								"max":     float64(domainErr.Max),
+								"min":     float64(domainErr.Min),
+							},
+							Path: []string{"$query", "cursor"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: len(cursor) > 1000",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("cursor", gofakeit.LetterN(1001))
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				domainErr := domain.LenOutOfRangeError{
+					Min:     1,
+					Max:     1000,
+					Current: len(req.URL.Query().Get("cursor")),
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"current": float64(domainErr.Current),
+								"max":     float64(domainErr.Max),
+								"min":     float64(domainErr.Min),
+							},
+							Path: []string{"$query", "cursor"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: invalid cursor",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("cursor", gofakeit.LetterN(100))
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				var domainErr domain.Error
+				require.ErrorAs(t, domain.ErrInvalidCursor, &domainErr)
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Path:    []string{"$query", "cursor"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: len(sort) > 1",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Add("sort", "date:DESC")
+				q.Add("sort", "date:ASC")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				domainErr := domain.LenOutOfRangeError{
+					Min:     0,
+					Max:     1,
+					Current: len(req.URL.Query()["sort"]),
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"current": float64(domainErr.Current),
+								"max":     float64(domainErr.Max),
+								"min":     float64(domainErr.Min),
+							},
+							Path: []string{"$query", "sort"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: invalid sort",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Add("sort", "date:")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				domainErr := domain.UnsupportedSortStringError{
+					Sort: req.URL.Query()["sort"][0],
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"sort": domainErr.Sort,
+							},
+							Path: []string{"$query", "sort", "0"},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: version not found",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				req.URL.Path = fmt.Sprintf(
+					endpointListServerServerSnapshots,
+					randInvalidVersionCode(t, handler),
+					server.Key,
+				)
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				pathSegments := strings.Split(req.URL.Path, "/")
+				require.Len(t, pathSegments, 7)
+				domainErr := domain.VersionNotFoundError{
+					VersionCode: pathSegments[3],
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"code": domainErr.VersionCode,
+							},
+						},
+					},
+				}, body)
+			},
+		},
+		{
+			name: "ERR: server not found",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				req.URL.Path = fmt.Sprintf(
+					endpointListServerServerSnapshots,
+					server.Version.Code,
+					domaintest.RandServerKey(),
+				)
+			},
+			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
+				pathSegments := strings.Split(req.URL.Path, "/")
+				require.Len(t, pathSegments, 7)
+				domainErr := domain.ServerNotFoundError{
+					Key: pathSegments[5],
+				}
+				assert.Equal(t, apimodel.ErrorResponse{
+					Errors: []apimodel.Error{
+						{
+							Code:    apimodel.ErrorCode(domainErr.Code()),
+							Message: domainErr.Error(),
+							Params: map[string]any{
+								"key": domainErr.Key,
+							},
+						},
+					},
+				}, body)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			req := httptest.NewRequest(
+				http.MethodGet,
+				fmt.Sprintf(endpointListServerServerSnapshots, server.Version.Code, server.Key),
+				nil,
+			)
+			if tt.reqModifier != nil {
+				tt.reqModifier(t, req)
+			}
+
+			resp := doCustomRequest(handler, req)
+			defer resp.Body.Close()
+			tt.assertResp(t, req, resp)
+		})
+	}
+}
+
+type serverSnapshotWithServer struct {
+	apimodel.ServerSnapshot
+	Server serverWithVersion
+}
+
+func getAllServerSnapshots(tb testing.TB, h http.Handler) []serverSnapshotWithServer {
+	tb.Helper()
+
+	servers := getAllServers(tb, h)
+
+	var sss []serverSnapshotWithServer
+
+	for _, s := range servers {
+		resp := doRequest(h, http.MethodGet, fmt.Sprintf(
+			endpointListServerServerSnapshots,
+			s.Version.Code,
+			s.Key,
+		), nil)
+		require.Equal(tb, http.StatusOK, resp.StatusCode)
+
+		for _, ts := range decodeJSON[apimodel.ListServerSnapshotsResponse](tb, resp.Body).Data {
+			sss = append(sss, serverSnapshotWithServer{
+				ServerSnapshot: ts,
+				Server:         s,
+			})
+		}
+
+		_ = resp.Body.Close()
+	}
+
+	require.NotZero(tb, sss)
+
+	return sss
+}

internal/port/handler_http_api_server_test.go

@@ -198,7 +198,7 @@ func TestListServers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -234,7 +234,7 @@ func TestListServers(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.ServerListMaxLimit,
 					Current: limit,
 				}

internal/port/handler_http_api_test.go

@@ -40,6 +40,7 @@ func newAPIHTTPHandler(tb testing.TB, opts ...func(cfg *apiHTTPHandlerConfig)) h
 	villageRepo := adapter.NewVillageBunRepository(bunDB)
 	ennoblementRepo := adapter.NewEnnoblementBunRepository(bunDB)
 	tribeChangeRepo := adapter.NewTribeChangeBunRepository(bunDB)
+	serverSnapshotRepo := adapter.NewServerSnapshotBunRepository(bunDB)
 	tribeSnapshotRepo := adapter.NewTribeSnapshotBunRepository(bunDB)
 	playerSnapshotRepo := adapter.NewPlayerSnapshotBunRepository(bunDB)
 
@@ -51,6 +52,7 @@ func newAPIHTTPHandler(tb testing.TB, opts ...func(cfg *apiHTTPHandlerConfig)) h
 		app.NewVillageService(villageRepo, nil, nil),
 		app.NewEnnoblementService(ennoblementRepo, nil, nil),
 		app.NewTribeChangeService(tribeChangeRepo),
+		app.NewServerSnapshotService(serverSnapshotRepo, nil, nil),
 		app.NewTribeSnapshotService(tribeSnapshotRepo, nil, nil),
 		app.NewPlayerSnapshotService(playerSnapshotRepo, nil, nil),
 		cfg.options...,

internal/port/handler_http_api_tribe.go

@@ -22,6 +22,8 @@ var apiTribeSortAllowedValues = []domain.TribeSort{
 	domain.TribeSortODScoreTotalDESC,
 	domain.TribeSortPointsASC,
 	domain.TribeSortPointsDESC,
+	domain.TribeSortMostPointsASC,
+	domain.TribeSortMostPointsDESC,
 	domain.TribeSortDominanceASC,
 	domain.TribeSortDominanceDESC,
 	domain.TribeSortDeletedAtASC,

internal/port/handler_http_api_tribe_change_test.go

@@ -273,7 +273,7 @@ func TestListPlayerTribeChanges(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -309,7 +309,7 @@ func TestListPlayerTribeChanges(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.TribeChangeListMaxLimit,
 					Current: limit,
 				}
@@ -965,7 +965,7 @@ func TestListTribeMemberChanges(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -1001,7 +1001,7 @@ func TestListTribeMemberChanges(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.TribeChangeListMaxLimit,
 					Current: limit,
 				}

internal/port/handler_http_api_tribe_snapshot_test.go

@@ -192,7 +192,7 @@ func TestListTribeTribeSnapshots(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -228,7 +228,7 @@ func TestListTribeTribeSnapshots(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.TribeSnapshotListMaxLimit,
 					Current: limit,
 				}

internal/port/handler_http_api_tribe_test.go

@@ -176,6 +176,32 @@ func TestListTribes(t *testing.T) {
 				}))
 			},
 		},
+		{
+			name: "OK: sort=[mostPoints:DESC]",
+			reqModifier: func(t *testing.T, req *http.Request) {
+				t.Helper()
+				q := req.URL.Query()
+				q.Set("sort", "mostPoints:DESC")
+				req.URL.RawQuery = q.Encode()
+			},
+			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
+				t.Helper()
+
+				assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+				// body
+				body := decodeJSON[apimodel.ListTribesResponse](t, resp.Body)
+				assert.Zero(t, body.Cursor.Next)
+				assert.NotZero(t, body.Cursor.Self)
+				assert.NotZero(t, body.Data)
+				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.Tribe) int {
+					return cmp.Or(
+						cmp.Compare(a.MostPoints, b.MostPoints)*-1,
+						cmp.Compare(a.Id, b.Id),
+					)
+				}))
+			},
+		},
 		{
 			name: "OK: tag",
 			reqModifier: func(t *testing.T, req *http.Request) {
@@ -301,7 +327,7 @@ func TestListTribes(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -337,7 +363,7 @@ func TestListTribes(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.TribeListMaxLimit,
 					Current: limit,
 				}
@@ -763,7 +789,7 @@ func TestGetTribe(t *testing.T) {
 				require.Len(t, pathSegments, 8)
 				id, err := strconv.Atoi(pathSegments[7])
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: id,
 				}

internal/port/handler_http_api_version_test.go

@@ -146,7 +146,7 @@ func TestListVersions(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -182,7 +182,7 @@ func TestListVersions(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.VersionListMaxLimit,
 					Current: limit,
 				}

internal/port/handler_http_api_village_test.go

@@ -185,7 +185,7 @@ func TestListVillages(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -221,7 +221,7 @@ func TestListVillages(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.VillageListMaxLimit,
 					Current: limit,
 				}
@@ -629,7 +629,7 @@ func TestListPlayerVillages(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -665,7 +665,7 @@ func TestListPlayerVillages(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.VillageListMaxLimit,
 					Current: limit,
 				}
@@ -1042,7 +1042,7 @@ func TestListTribeVillages(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: limit,
 				}
@@ -1078,7 +1078,7 @@ func TestListTribeVillages(t *testing.T) {
 				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
 				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
 				require.NoError(t, err)
-				domainErr := domain.MaxLessEqualError{
+				domainErr := domain.MaxLessEqualError[int]{
 					Max:     domain.VillageListMaxLimit,
 					Current: limit,
 				}
@@ -1363,7 +1363,7 @@ func TestGetVillage(t *testing.T) {
 				require.Len(t, pathSegments, 8)
 				id, err := strconv.Atoi(pathSegments[7])
 				require.NoError(t, err)
-				domainErr := domain.MinGreaterEqualError{
+				domainErr := domain.MinGreaterEqualError[int]{
 					Min:     1,
 					Current: id,
 				}

internal/port/internal/apimodel/server_snapshot.go

@@ -0,0 +1,43 @@
+package apimodel
+
+import (
+	"gitea.dwysokinski.me/twhelp/core/internal/domain"
+	oapitypes "github.com/oapi-codegen/runtime/types"
+)
+
+func NewServerSnapshot(withRelations domain.ServerSnapshotWithRelations) ServerSnapshot {
+	ss := withRelations.ServerSnapshot()
+	return ServerSnapshot{
+		Date:                 oapitypes.Date{Time: ss.Date()},
+		Id:                   ss.ID(),
+		NumActivePlayers:     ss.NumActivePlayers(),
+		NumActiveTribes:      ss.NumActiveTribes(),
+		NumBarbarianVillages: ss.NumBarbarianVillages(),
+		NumBonusVillages:     ss.NumBonusVillages(),
+		NumInactivePlayers:   ss.NumInactivePlayers(),
+		NumInactiveTribes:    ss.NumInactiveTribes(),
+		NumPlayerVillages:    ss.NumPlayerVillages(),
+		NumPlayers:           ss.NumPlayers(),
+		NumTribes:            ss.NumTribes(),
+		NumVillages:          ss.NumVillages(),
+		Server:               NewServerMeta(withRelations.Server()),
+	}
+}
+
+func NewListServerSnapshotsResponse(res domain.ListServerSnapshotsWithRelationsResult) ListServerSnapshotsResponse {
+	sss := res.ServerSnapshots()
+
+	resp := ListServerSnapshotsResponse{
+		Data: make([]ServerSnapshot, 0, len(sss)),
+		Cursor: Cursor{
+			Next: res.Next().Encode(),
+			Self: res.Self().Encode(),
+		},
+	}
+
+	for _, ss := range sss {
+		resp.Data = append(resp.Data, NewServerSnapshot(ss))
+	}
+
+	return resp
+}

internal/port/testdata/snapshotcreation/fixture.yml

@@ -5,8 +5,12 @@
       url: https://pl169.plemiona.pl
       open: true
       special: false
+      num_players: 10000
       num_active_players: 2001
+      num_inactive_players: 7999
+      num_tribes: 500
       num_active_tribes: 214
+      num_inactive_tribes: 286
       num_villages: 49074
       num_player_villages: 48500
       num_barbarian_villages: 1574

k8s/base/api.yml

@@ -39,8 +39,6 @@ spec:
                   key: rabbitmq-connection-string
             - name: AUTO_MAX_PROCS
               value: "true"
-            - name: API_OPENAPI_SERVERS
-              value: https://twhelp.app,https://tribalwarshelp.com
           resources:
             requests:
               cpu: 20m

k8s/overlays/prod/api.yml

@@ -29,3 +29,5 @@ spec:
                   key: rabbitmq-connection-string
             - name: AUTO_MAX_PROCS
               value: "true"
+            - name: API_OPENAPI_SERVERS
+              value: https://twhelp.app,https://tribalwarshelp.com