[WIP] - refactor limit, sort, offset

- update the ServerStats/Tribe/TribeChange/TribeHistory repository and usecase

graphql/generated/generated.go

@@ -226,12 +226,12 @@ type ComplexityRoot struct {
 		PlayerHistory    func(childComplexity int, server string, filter *models.PlayerHistoryFilter, limit *int, offset *int, sort []string) int
 		Players          func(childComplexity int, server string, filter *models.PlayerFilter, limit *int, offset *int, sort []string) int
 		Server           func(childComplexity int, key string) int
-		ServerStats      func(childComplexity int, server string, filter *models.ServerStatsFilter) int
+		ServerStats      func(childComplexity int, server string, filter *models.ServerStatsFilter, limit *int, offset *int, sort []string) int
 		Servers          func(childComplexity int, filter *models.ServerFilter, limit *int, offset *int, sort []string) int
 		Tribe            func(childComplexity int, server string, id int) int
-		TribeChanges     func(childComplexity int, server string, filter *models.TribeChangeFilter) int
+		TribeChanges     func(childComplexity int, server string, filter *models.TribeChangeFilter, limit *int, offset *int, sort []string) int
-		TribeHistory     func(childComplexity int, server string, filter *models.TribeHistoryFilter) int
+		TribeHistory     func(childComplexity int, server string, filter *models.TribeHistoryFilter, limit *int, offset *int, sort []string) int
-		Tribes           func(childComplexity int, server string, filter *models.TribeFilter) int
+		Tribes           func(childComplexity int, server string, filter *models.TribeFilter, limit *int, offset *int, sort []string) int
 		Version          func(childComplexity int, code models.VersionCode) int
 		Versions         func(childComplexity int, filter *models.VersionFilter) int
 		Village          func(childComplexity int, server string, id int) int
@@ -588,11 +588,11 @@ type QueryResolver interface {
 	PlayerHistory(ctx context.Context, server string, filter *models.PlayerHistoryFilter, limit *int, offset *int, sort []string) (*PlayerHistory, error)
 	Servers(ctx context.Context, filter *models.ServerFilter, limit *int, offset *int, sort []string) (*ServerList, error)
 	Server(ctx context.Context, key string) (*models.Server, error)
-	ServerStats(ctx context.Context, server string, filter *models.ServerStatsFilter) (*ServerStats, error)
+	ServerStats(ctx context.Context, server string, filter *models.ServerStatsFilter, limit *int, offset *int, sort []string) (*ServerStats, error)
-	Tribes(ctx context.Context, server string, filter *models.TribeFilter) (*TribeList, error)
+	Tribes(ctx context.Context, server string, filter *models.TribeFilter, limit *int, offset *int, sort []string) (*TribeList, error)
 	Tribe(ctx context.Context, server string, id int) (*models.Tribe, error)
-	TribeChanges(ctx context.Context, server string, filter *models.TribeChangeFilter) (*TribeChanges, error)
+	TribeChanges(ctx context.Context, server string, filter *models.TribeChangeFilter, limit *int, offset *int, sort []string) (*TribeChanges, error)
-	TribeHistory(ctx context.Context, server string, filter *models.TribeHistoryFilter) (*TribeHistory, error)
+	TribeHistory(ctx context.Context, server string, filter *models.TribeHistoryFilter, limit *int, offset *int, sort []string) (*TribeHistory, error)
 	LangVersions(ctx context.Context, filter *models.VersionFilter) (*VersionList, error)
 	LangVersion(ctx context.Context, tag models.VersionCode) (*models.Version, error)
 	Versions(ctx context.Context, filter *models.VersionFilter) (*VersionList, error)
@@ -1597,7 +1597,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 			return 0, false
 		}
 
-		return e.complexity.Query.ServerStats(childComplexity, args["server"].(string), args["filter"].(*models.ServerStatsFilter)), true
+		return e.complexity.Query.ServerStats(childComplexity, args["server"].(string), args["filter"].(*models.ServerStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true
 
 	case "Query.servers":
 		if e.complexity.Query.Servers == nil {
@@ -1633,7 +1633,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 			return 0, false
 		}
 
-		return e.complexity.Query.TribeChanges(childComplexity, args["server"].(string), args["filter"].(*models.TribeChangeFilter)), true
+		return e.complexity.Query.TribeChanges(childComplexity, args["server"].(string), args["filter"].(*models.TribeChangeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true
 
 	case "Query.tribeHistory":
 		if e.complexity.Query.TribeHistory == nil {
@@ -1645,7 +1645,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 			return 0, false
 		}
 
-		return e.complexity.Query.TribeHistory(childComplexity, args["server"].(string), args["filter"].(*models.TribeHistoryFilter)), true
+		return e.complexity.Query.TribeHistory(childComplexity, args["server"].(string), args["filter"].(*models.TribeHistoryFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true
 
 	case "Query.tribes":
 		if e.complexity.Query.Tribes == nil {
@@ -1657,7 +1657,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 			return 0, false
 		}
 
-		return e.complexity.Query.Tribes(childComplexity, args["server"].(string), args["filter"].(*models.TribeFilter)), true
+		return e.complexity.Query.Tribes(childComplexity, args["server"].(string), args["filter"].(*models.TribeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true
 
 	case "Query.version":
 		if e.complexity.Query.Version == nil {
@@ -3983,12 +3983,27 @@ input ServerStatsFilter {
   createDateLTE: Time
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query serverStats - ` + "`" + `offset` + "`" + `."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query serverStats - ` + "`" + `limit` + "`" + `."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query serverStats - ` + "`" + `sort` + "`" + `."
+    )
 }
 
 extend type Query {
-  serverStats(server: String!, filter: ServerStatsFilter): ServerStats!
+  serverStats(
+    server: String!
+    filter: ServerStatsFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): ServerStats!
 }
 `, BuiltIn: false},
 	{Name: "schema/tribe.graphql", Input: `type Tribe {
@@ -4124,12 +4139,27 @@ input TribeFilter {
   deletedAtLTE: Time
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribes - ` + "`" + `offset` + "`" + `."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribes - ` + "`" + `limit` + "`" + `."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query tribes - ` + "`" + `sort` + "`" + `."
+    )
 }
 
 extend type Query {
-  tribes(server: String!, filter: TribeFilter): TribeList!
+  tribes(
+    server: String!
+    filter: TribeFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): TribeList!
   tribe(server: String!, id: Int!): Tribe
 }
 `, BuiltIn: false},
@@ -4169,12 +4199,27 @@ input TribeChangeFilter {
   or: TribeChangeFilterOr
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeChanges - ` + "`" + `offset` + "`" + `."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeChanges - ` + "`" + `limit` + "`" + `."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query tribeChanges - ` + "`" + `sort` + "`" + `."
+    )
 }
 
 extend type Query {
-  tribeChanges(server: String!, filter: TribeChangeFilter): TribeChanges!
+  tribeChanges(
+    server: String!
+    filter: TribeChangeFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): TribeChanges!
 }
 `, BuiltIn: false},
 	{Name: "schema/tribe_history.graphql", Input: `type TribeHistoryRecord {
@@ -4210,12 +4255,27 @@ input TribeHistoryFilter {
   createDateLTE: Time
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeHistory - ` + "`" + `offset` + "`" + `."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeHistory - ` + "`" + `limit` + "`" + `."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query tribeHistory - ` + "`" + `sort` + "`" + `."
+    )
 }
 
 extend type Query {
-  tribeHistory(server: String!, filter: TribeHistoryFilter): TribeHistory!
+  tribeHistory(
+    server: String!
+    filter: TribeHistoryFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): TribeHistory!
 }
 `, BuiltIn: false},
 	{Name: "schema/unit_config.graphql", Input: `type Unit {
@@ -4728,6 +4788,33 @@ func (ec *executionContext) field_Query_serverStats_args(ctx context.Context, ra
 		}
 	}
 	args["filter"] = arg1
+	var arg2 *int
+	if tmp, ok := rawArgs["limit"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
+		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["limit"] = arg2
+	var arg3 *int
+	if tmp, ok := rawArgs["offset"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
+		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["offset"] = arg3
+	var arg4 []string
+	if tmp, ok := rawArgs["sort"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
+		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["sort"] = arg4
 	return args, nil
 }
 
@@ -4809,6 +4896,33 @@ func (ec *executionContext) field_Query_tribeChanges_args(ctx context.Context, r
 		}
 	}
 	args["filter"] = arg1
+	var arg2 *int
+	if tmp, ok := rawArgs["limit"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
+		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["limit"] = arg2
+	var arg3 *int
+	if tmp, ok := rawArgs["offset"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
+		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["offset"] = arg3
+	var arg4 []string
+	if tmp, ok := rawArgs["sort"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
+		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["sort"] = arg4
 	return args, nil
 }
 
@@ -4833,6 +4947,33 @@ func (ec *executionContext) field_Query_tribeHistory_args(ctx context.Context, r
 		}
 	}
 	args["filter"] = arg1
+	var arg2 *int
+	if tmp, ok := rawArgs["limit"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
+		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["limit"] = arg2
+	var arg3 *int
+	if tmp, ok := rawArgs["offset"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
+		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["offset"] = arg3
+	var arg4 []string
+	if tmp, ok := rawArgs["sort"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
+		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["sort"] = arg4
 	return args, nil
 }
 
@@ -4881,6 +5022,33 @@ func (ec *executionContext) field_Query_tribes_args(ctx context.Context, rawArgs
 		}
 	}
 	args["filter"] = arg1
+	var arg2 *int
+	if tmp, ok := rawArgs["limit"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
+		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["limit"] = arg2
+	var arg3 *int
+	if tmp, ok := rawArgs["offset"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
+		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["offset"] = arg3
+	var arg4 []string
+	if tmp, ok := rawArgs["sort"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
+		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["sort"] = arg4
 	return args, nil
 }
 
@@ -9502,7 +9670,7 @@ func (ec *executionContext) _Query_serverStats(ctx context.Context, field graphq
 	fc.Args = args
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Query().ServerStats(rctx, args["server"].(string), args["filter"].(*models.ServerStatsFilter))
+		return ec.resolvers.Query().ServerStats(rctx, args["server"].(string), args["filter"].(*models.ServerStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -9544,7 +9712,7 @@ func (ec *executionContext) _Query_tribes(ctx context.Context, field graphql.Col
 	fc.Args = args
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Query().Tribes(rctx, args["server"].(string), args["filter"].(*models.TribeFilter))
+		return ec.resolvers.Query().Tribes(rctx, args["server"].(string), args["filter"].(*models.TribeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -9625,7 +9793,7 @@ func (ec *executionContext) _Query_tribeChanges(ctx context.Context, field graph
 	fc.Args = args
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Query().TribeChanges(rctx, args["server"].(string), args["filter"].(*models.TribeChangeFilter))
+		return ec.resolvers.Query().TribeChanges(rctx, args["server"].(string), args["filter"].(*models.TribeChangeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -9667,7 +9835,7 @@ func (ec *executionContext) _Query_tribeHistory(ctx context.Context, field graph
 	fc.Args = args
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Query().TribeHistory(rctx, args["server"].(string), args["filter"].(*models.TribeHistoryFilter))
+		return ec.resolvers.Query().TribeHistory(rctx, args["server"].(string), args["filter"].(*models.TribeHistoryFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
 	})
 	if err != nil {
 		ec.Error(ctx, err)

graphql/resolvers/player_history.go

@@ -26,7 +26,8 @@ func (r *playerHistoryRecordResolver) Tribe(ctx context.Context, obj *models.Pla
 
 func (r *Resolver) PlayerHistory(ctx context.Context,
 	server string,
-	f *models.PlayerHistoryFilter, limit *int,
+	f *models.PlayerHistoryFilter,
+	limit *int,
 	offset *int,
 	sort []string) (*generated.PlayerHistory, error) {
 	defLimit := 0

graphql/resolvers/server.go

@@ -24,7 +24,8 @@ func (r *serverResolver) LangVersion(ctx context.Context, obj *models.Server) (*
 }
 
 func (r *queryResolver) Servers(ctx context.Context,
-	f *models.ServerFilter, limit *int,
+	f *models.ServerFilter,
+	limit *int,
 	offset *int,
 	sort []string) (*generated.ServerList, error) {
 	defLimit := 0

graphql/resolvers/server_stats.go

@@ -4,12 +4,34 @@ import (
 	"context"
 
 	"github.com/tribalwarshelp/api/graphql/generated"
+	"github.com/tribalwarshelp/api/serverstats"
 	"github.com/tribalwarshelp/shared/models"
 )
 
-func (r *Resolver) ServerStats(ctx context.Context, server string, filter *models.ServerStatsFilter) (*generated.ServerStats, error) {
+func (r *Resolver) ServerStats(ctx context.Context,
+	server string,
+	f *models.ServerStatsFilter,
+	limit *int,
+	offset *int,
+	sort []string) (*generated.ServerStats, error) {
+	defLimit := 0
+	defOffset := 0
+	if limit == nil {
+		limit = &defLimit
+	}
+	if offset == nil {
+		offset = &defOffset
+	}
+
 	var err error
 	list := &generated.ServerStats{}
-	list.Items, list.Total, err = r.ServerStatsUcase.Fetch(ctx, server, filter)
+	list.Items, list.Total, err = r.ServerStatsUcase.Fetch(ctx, serverstats.FetchConfig{
+		Server: server,
+		Filter: f,
+		Sort:   sort,
+		Limit:  *limit,
+		Offset: *offset,
+		Count:  true,
+	})
 	return list, err
 }

graphql/resolvers/tribe.go

@@ -4,13 +4,35 @@ import (
 	"context"
 
 	"github.com/tribalwarshelp/api/graphql/generated"
+	"github.com/tribalwarshelp/api/tribe"
 	"github.com/tribalwarshelp/shared/models"
 )
 
-func (r *queryResolver) Tribes(ctx context.Context, server string, filter *models.TribeFilter) (*generated.TribeList, error) {
+func (r *queryResolver) Tribes(ctx context.Context,
+	server string,
+	f *models.TribeFilter,
+	limit *int,
+	offset *int,
+	sort []string) (*generated.TribeList, error) {
+	defLimit := 0
+	defOffset := 0
+	if limit == nil {
+		limit = &defLimit
+	}
+	if offset == nil {
+		offset = &defOffset
+	}
+
 	var err error
 	list := &generated.TribeList{}
-	list.Items, list.Total, err = r.TribeUcase.Fetch(ctx, server, filter)
+	list.Items, list.Total, err = r.TribeUcase.Fetch(ctx, tribe.FetchConfig{
+		Server: server,
+		Filter: f,
+		Sort:   sort,
+		Limit:  *limit,
+		Offset: *offset,
+		Count:  true,
+	})
 	return list, err
 }
 

graphql/resolvers/tribe_change.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/tribalwarshelp/api/graphql/generated"
+	"github.com/tribalwarshelp/api/tribechange"
 	"github.com/tribalwarshelp/shared/models"
 )
 
@@ -31,9 +32,29 @@ func (r *tribeChangeRecordResolver) OldTribe(ctx context.Context, obj *models.Tr
 	return getTribe(ctx, obj.OldTribeID), nil
 }
 
-func (r *Resolver) TribeChanges(ctx context.Context, server string, filter *models.TribeChangeFilter) (*generated.TribeChanges, error) {
+func (r *Resolver) TribeChanges(ctx context.Context,
+	server string,
+	f *models.TribeChangeFilter,
+	limit *int,
+	offset *int,
+	sort []string) (*generated.TribeChanges, error) {
+	defLimit := 0
+	defOffset := 0
+	if limit == nil {
+		limit = &defLimit
+	}
+	if offset == nil {
+		offset = &defOffset
+	}
+
 	var err error
 	list := &generated.TribeChanges{}
-	list.Items, list.Total, err = r.TribeChangeUcase.Fetch(ctx, server, filter)
+	list.Items, list.Total, err = r.TribeChangeUcase.Fetch(ctx, tribechange.FetchConfig{
+		Filter: f,
+		Sort:   sort,
+		Limit:  *limit,
+		Offset: *offset,
+		Count:  true,
+	})
 	return list, err
 }

graphql/resolvers/tribe_history.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/tribalwarshelp/api/graphql/generated"
+	"github.com/tribalwarshelp/api/tribehistory"
 	"github.com/tribalwarshelp/shared/models"
 )
 
@@ -15,9 +16,29 @@ func (r *tribeHistoryRecordResolver) Tribe(ctx context.Context, obj *models.Trib
 	return getTribe(ctx, obj.TribeID), nil
 }
 
-func (r *Resolver) TribeHistory(ctx context.Context, server string, filter *models.TribeHistoryFilter) (*generated.TribeHistory, error) {
+func (r *Resolver) TribeHistory(ctx context.Context,
+	server string,
+	f *models.TribeHistoryFilter,
+	limit *int,
+	offset *int,
+	sort []string) (*generated.TribeHistory, error) {
+	defLimit := 0
+	defOffset := 0
+	if limit == nil {
+		limit = &defLimit
+	}
+	if offset == nil {
+		offset = &defOffset
+	}
+
 	var err error
 	list := &generated.TribeHistory{}
-	list.Items, list.Total, err = r.TribeHistoryUcase.Fetch(ctx, server, filter)
+	list.Items, list.Total, err = r.TribeHistoryUcase.Fetch(ctx, tribehistory.FetchConfig{
+		Filter: f,
+		Sort:   sort,
+		Limit:  *limit,
+		Offset: *offset,
+		Count:  true,
+	})
 	return list, err
 }

graphql/schema/server_stats.graphql

@@ -25,10 +25,25 @@ input ServerStatsFilter {
   createDateLTE: Time
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query serverStats - `offset`."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query serverStats - `limit`."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query serverStats - `sort`."
+    )
 }
 
 extend type Query {
-  serverStats(server: String!, filter: ServerStatsFilter): ServerStats!
+  serverStats(
+    server: String!
+    filter: ServerStatsFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): ServerStats!
 }

graphql/schema/tribe.graphql

@@ -131,11 +131,26 @@ input TribeFilter {
   deletedAtLTE: Time
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribes - `offset`."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribes - `limit`."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query tribes - `sort`."
+    )
 }
 
 extend type Query {
-  tribes(server: String!, filter: TribeFilter): TribeList!
+  tribes(
+    server: String!
+    filter: TribeFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): TribeList!
   tribe(server: String!, id: Int!): Tribe
 }

graphql/schema/tribe_change.graphql

@@ -34,10 +34,25 @@ input TribeChangeFilter {
   or: TribeChangeFilterOr
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeChanges - `offset`."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeChanges - `limit`."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query tribeChanges - `sort`."
+    )
 }
 
 extend type Query {
-  tribeChanges(server: String!, filter: TribeChangeFilter): TribeChanges!
+  tribeChanges(
+    server: String!
+    filter: TribeChangeFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): TribeChanges!
 }

graphql/schema/tribe_history.graphql

@@ -31,10 +31,25 @@ input TribeHistoryFilter {
   createDateLTE: Time
 
   offset: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeHistory - `offset`."
+    )
   limit: Int
+    @deprecated(
+      reason: "Use a new variable added to the query tribeHistory - `limit`."
+    )
   sort: String
+    @deprecated(
+      reason: "Use a new variable added to the query tribeHistory - `sort`."
+    )
 }
 
 extend type Query {
-  tribeHistory(server: String!, filter: TribeHistoryFilter): TribeHistory!
+  tribeHistory(
+    server: String!
+    filter: TribeHistoryFilter
+    limit: Int
+    offset: Int
+    sort: [String!]
+  ): TribeHistory!
 }

serverstats/repository.go

@@ -10,6 +10,9 @@ type FetchConfig struct {
 	Server string
 	Filter *models.ServerStatsFilter
 	Count  bool
+	Sort   []string
+	Limit  int
+	Offset int
 }
 
 type Repository interface {

serverstats/repository/pg_repository.go

@@ -23,17 +23,17 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg serverstats.FetchConfig
 	var err error
 	data := []*models.ServerStats{}
 	total := 0
-	query := repo.WithParam("SERVER", pg.Safe(cfg.Server)).Model(&data).Context(ctx)
+	query := repo.
+		WithParam("SERVER", pg.Safe(cfg.Server)).
+		Model(&data).
+		Context(ctx).
+		Order(cfg.Sort...).
+		Limit(cfg.Limit).
+		Offset(cfg.Offset)
 
 	if cfg.Filter != nil {
 		query = query.
-			WhereStruct(cfg.Filter).
+			WhereStruct(cfg.Filter)
-			Limit(cfg.Filter.Limit).
-			Offset(cfg.Filter.Offset)
-
-		if cfg.Filter.Sort != "" {
-			query = query.Order(cfg.Filter.Sort)
-		}
 	}
 
 	if cfg.Count {

serverstats/usecase.go

@@ -7,5 +7,5 @@ import (
 )
 
 type Usecase interface {
-	Fetch(ctx context.Context, server string, filter *models.ServerStatsFilter) ([]*models.ServerStats, int, error)
+	Fetch(ctx context.Context, cfg FetchConfig) ([]*models.ServerStats, int, error)
 }

serverstats/usecase/serverstats_usecase.go

@@ -17,17 +17,22 @@ func New(repo serverstats.Repository) serverstats.Usecase {
 	return &usecase{repo}
 }
 
-func (ucase *usecase) Fetch(ctx context.Context, server string, filter *models.ServerStatsFilter) ([]*models.ServerStats, int, error) {
+func (ucase *usecase) Fetch(ctx context.Context, cfg serverstats.FetchConfig) ([]*models.ServerStats, int, error) {
-	if filter == nil {
+	if cfg.Filter == nil {
-		filter = &models.ServerStatsFilter{}
+		cfg.Filter = &models.ServerStatsFilter{}
 	}
-	if !middleware.CanExceedLimit(ctx) && (filter.Limit > serverstats.PaginationLimit || filter.Limit <= 0) {
+	if cfg.Filter.Limit > 0 {
-		filter.Limit = serverstats.PaginationLimit
+		cfg.Limit = cfg.Filter.Limit
 	}
-	filter.Sort = utils.SanitizeSortExpression(filter.Sort)
+	if cfg.Filter.Offset > 0 {
-	return ucase.repo.Fetch(ctx, serverstats.FetchConfig{
+		cfg.Offset = cfg.Filter.Offset
-		Server: server,
+	}
-		Filter: filter,
+	if cfg.Filter.Sort != "" {
-		Count:  true,
+		cfg.Sort = append(cfg.Sort, cfg.Filter.Sort)
-	})
+	}
+	if !middleware.CanExceedLimit(ctx) && (cfg.Limit > serverstats.PaginationLimit || cfg.Limit <= 0) {
+		cfg.Limit = serverstats.PaginationLimit
+	}
+	cfg.Sort = utils.SanitizeSortExpressions(cfg.Sort)
+	return ucase.repo.Fetch(ctx, cfg)
 }

tribe/repository.go

@@ -10,6 +10,9 @@ type FetchConfig struct {
 	Server string
 	Filter *models.TribeFilter
 	Count  bool
+	Sort   []string
+	Limit  int
+	Offset int
 }
 
 type Repository interface {

tribe/repository/pg_repository.go

@@ -23,17 +23,16 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg tribe.FetchConfig) ([]*
 	var err error
 	data := []*models.Tribe{}
 	total := 0
-	query := repo.WithParam("SERVER", pg.Safe(cfg.Server)).Model(&data).Context(ctx)
+	query := repo.
-
+		WithParam("SERVER", pg.Safe(cfg.Server)).
+		Model(&data).
+		Context(ctx).
+		Order(cfg.Sort...).
+		Limit(cfg.Limit).
+		Offset(cfg.Offset)
 	if cfg.Filter != nil {
 		query = query.
-			WhereStruct(cfg.Filter).
+			WhereStruct(cfg.Filter)
-			Limit(cfg.Filter.Limit).
-			Offset(cfg.Filter.Offset)
-
-		if cfg.Filter.Sort != "" {
-			query = query.Order(cfg.Filter.Sort)
-		}
 
 		if cfg.Filter.Exists != nil {
 			query = query.Where("exists = ?", *cfg.Filter.Exists)

tribe/usecase.go

@@ -7,6 +7,6 @@ import (
 )
 
 type Usecase interface {
-	Fetch(ctx context.Context, server string, filter *models.TribeFilter) ([]*models.Tribe, int, error)
+	Fetch(ctx context.Context, cfg FetchConfig) ([]*models.Tribe, int, error)
 	GetByID(ctx context.Context, server string, id int) (*models.Tribe, error)
 }

tribe/usecase/tribe_usecase.go

@@ -18,28 +18,34 @@ func New(repo tribe.Repository) tribe.Usecase {
 	return &usecase{repo}
 }
 
-func (ucase *usecase) Fetch(ctx context.Context, server string, filter *models.TribeFilter) ([]*models.Tribe, int, error) {
+func (ucase *usecase) Fetch(ctx context.Context, cfg tribe.FetchConfig) ([]*models.Tribe, int, error) {
-	if filter == nil {
+	if cfg.Filter == nil {
-		filter = &models.TribeFilter{}
+		cfg.Filter = &models.TribeFilter{}
 	}
-	if !middleware.CanExceedLimit(ctx) && (filter.Limit > tribe.PaginationLimit || filter.Limit <= 0) {
+	if cfg.Filter.Limit > 0 {
-		filter.Limit = tribe.PaginationLimit
+		cfg.Limit = cfg.Filter.Limit
 	}
-	filter.Sort = utils.SanitizeSortExpression(filter.Sort)
+	if cfg.Filter.Offset > 0 {
-	return ucase.repo.Fetch(ctx, tribe.FetchConfig{
+		cfg.Offset = cfg.Filter.Offset
-		Filter: filter,
+	}
-		Server: server,
+	if cfg.Filter.Sort != "" {
-		Count:  true,
+		cfg.Sort = append(cfg.Sort, cfg.Filter.Sort)
-	})
+	}
+	if !middleware.CanExceedLimit(ctx) && (cfg.Limit > tribe.PaginationLimit || cfg.Limit <= 0) {
+		cfg.Limit = tribe.PaginationLimit
+	}
+	cfg.Sort = utils.SanitizeSortExpressions(cfg.Sort)
+	return ucase.repo.Fetch(ctx, cfg)
 }
 
 func (ucase *usecase) GetByID(ctx context.Context, server string, id int) (*models.Tribe, error) {
 	tribes, _, err := ucase.repo.Fetch(ctx, tribe.FetchConfig{
 		Filter: &models.TribeFilter{
-			ID:    []int{id},
+			ID: []int{id},
-			Limit: 1,
 		},
+		Limit:  1,
 		Server: server,
+		Count:  false,
 	})
 	if err != nil {
 		return nil, err

tribechange/repository.go

@@ -10,6 +10,9 @@ type FetchConfig struct {
 	Server string
 	Filter *models.TribeChangeFilter
 	Count  bool
+	Sort   []string
+	Limit  int
+	Offset int
 }
 
 type Repository interface {

tribechange/repository/pg_repository.go

@@ -8,6 +8,7 @@ import (
 	"github.com/go-pg/pg/v10"
 	"github.com/pkg/errors"
 	"github.com/tribalwarshelp/api/tribechange"
+	"github.com/tribalwarshelp/api/utils"
 	"github.com/tribalwarshelp/shared/models"
 )
 
@@ -23,22 +24,33 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg tribechange.FetchConfig
 	var err error
 	total := 0
 	data := []*models.TribeChange{}
-	query := repo.WithParam("SERVER", pg.Safe(cfg.Server)).Model(&data).Context(ctx)
+	query := repo.
-
+		WithParam("SERVER", pg.Safe(cfg.Server)).
+		Model(&data).
+		Context(ctx).
+		Order(cfg.Sort...).
+		Limit(cfg.Limit).
+		Offset(cfg.Offset)
+	playerRequired := utils.FindStringWithPrefix(cfg.Sort, "player.") != ""
+	oldTribeRequired := utils.FindStringWithPrefix(cfg.Sort, "old_tribe.") != ""
+	newTribeRequired := utils.FindStringWithPrefix(cfg.Sort, "new_tribe.") != ""
 	if cfg.Filter != nil {
 		query = query.
-			WhereStruct(cfg.Filter).
+			WhereStruct(cfg.Filter)
-			Limit(cfg.Filter.Limit).
-			Offset(cfg.Filter.Offset)
-
-		if cfg.Filter.Sort != "" {
-			query = query.Order(cfg.Filter.Sort)
-		}
 
 		if cfg.Filter.Or != nil {
 			query = query.WhereGroup(appendTribeChangeFilterOr(cfg.Filter.Or))
 		}
 	}
+	if playerRequired {
+		query = query.Relation("Village._")
+	}
+	if oldTribeRequired {
+		query = query.Join("LEFT JOIN ?SERVER.tribes AS old_tribe ON old_tribe.id = ennoblement.old_tribe_id")
+	}
+	if newTribeRequired {
+		query = query.Join("LEFT JOIN ?SERVER.tribes AS new_tribe ON new_tribe.id = ennoblement.new_tribe_id")
+	}
 
 	if cfg.Count {
 		total, err = query.SelectAndCount()

tribechange/usecase.go

@@ -7,5 +7,5 @@ import (
 )
 
 type Usecase interface {
-	Fetch(ctx context.Context, server string, filter *models.TribeChangeFilter) ([]*models.TribeChange, int, error)
+	Fetch(ctx context.Context, cfg FetchConfig) ([]*models.TribeChange, int, error)
 }

tribechange/usecase/tribechange_usecase.go

@@ -17,17 +17,22 @@ func New(repo tribechange.Repository) tribechange.Usecase {
 	return &usecase{repo}
 }
 
-func (ucase *usecase) Fetch(ctx context.Context, server string, filter *models.TribeChangeFilter) ([]*models.TribeChange, int, error) {
+func (ucase *usecase) Fetch(ctx context.Context, cfg tribechange.FetchConfig) ([]*models.TribeChange, int, error) {
-	if filter == nil {
+	if cfg.Filter == nil {
-		filter = &models.TribeChangeFilter{}
+		cfg.Filter = &models.TribeChangeFilter{}
 	}
-	if !middleware.CanExceedLimit(ctx) && (filter.Limit > tribechange.PaginationLimit || filter.Limit <= 0) {
+	if cfg.Filter.Limit > 0 {
-		filter.Limit = tribechange.PaginationLimit
+		cfg.Limit = cfg.Filter.Limit
 	}
-	filter.Sort = utils.SanitizeSortExpression(filter.Sort)
+	if cfg.Filter.Offset > 0 {
-	return ucase.repo.Fetch(ctx, tribechange.FetchConfig{
+		cfg.Offset = cfg.Filter.Offset
-		Server: server,
+	}
-		Filter: filter,
+	if cfg.Filter.Sort != "" {
-		Count:  true,
+		cfg.Sort = append(cfg.Sort, cfg.Filter.Sort)
-	})
+	}
+	if !middleware.CanExceedLimit(ctx) && (cfg.Limit > tribechange.PaginationLimit || cfg.Limit <= 0) {
+		cfg.Limit = tribechange.PaginationLimit
+	}
+	cfg.Sort = utils.SanitizeSortExpressions(cfg.Sort)
+	return ucase.repo.Fetch(ctx, cfg)
 }

tribehistory/repository.go

@@ -10,6 +10,9 @@ type FetchConfig struct {
 	Server string
 	Filter *models.TribeHistoryFilter
 	Count  bool
+	Sort   []string
+	Limit  int
+	Offset int
 }
 
 type Repository interface {

tribehistory/repository/pg_repository.go

@@ -8,6 +8,7 @@ import (
 	"github.com/go-pg/pg/v10"
 	"github.com/pkg/errors"
 	"github.com/tribalwarshelp/api/tribehistory"
+	"github.com/tribalwarshelp/api/utils"
 	"github.com/tribalwarshelp/shared/models"
 )
 
@@ -23,17 +24,20 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg tribehistory.FetchConfi
 	var err error
 	total := 0
 	data := []*models.TribeHistory{}
-	query := repo.WithParam("SERVER", pg.Safe(cfg.Server)).Model(&data).Context(ctx)
+	query := repo.
-
+		WithParam("SERVER", pg.Safe(cfg.Server)).
+		Model(&data).
+		Context(ctx).
+		Order(cfg.Sort...).
+		Limit(cfg.Limit).
+		Offset(cfg.Offset)
+	tribeRequired := utils.FindStringWithPrefix(cfg.Sort, "tribe.") != ""
 	if cfg.Filter != nil {
 		query = query.
-			WhereStruct(cfg.Filter).
+			WhereStruct(cfg.Filter)
-			Limit(cfg.Filter.Limit).
+	}
-			Offset(cfg.Filter.Offset)
+	if tribeRequired {
-
+		query = query.Relation("Tribe._")
-		if cfg.Filter.Sort != "" {
-			query = query.Order(cfg.Filter.Sort)
-		}
 	}
 
 	if cfg.Count {

tribehistory/usecase.go

@@ -7,5 +7,5 @@ import (
 )
 
 type Usecase interface {
-	Fetch(ctx context.Context, server string, filter *models.TribeHistoryFilter) ([]*models.TribeHistory, int, error)
+	Fetch(ctx context.Context, cfg FetchConfig) ([]*models.TribeHistory, int, error)
 }

tribehistory/usecase/tribehistory_usecase.go

@@ -17,17 +17,22 @@ func New(repo tribehistory.Repository) tribehistory.Usecase {
 	return &usecase{repo}
 }
 
-func (ucase *usecase) Fetch(ctx context.Context, server string, filter *models.TribeHistoryFilter) ([]*models.TribeHistory, int, error) {
+func (ucase *usecase) Fetch(ctx context.Context, cfg tribehistory.FetchConfig) ([]*models.TribeHistory, int, error) {
-	if filter == nil {
+	if cfg.Filter == nil {
-		filter = &models.TribeHistoryFilter{}
+		cfg.Filter = &models.TribeHistoryFilter{}
 	}
-	if !middleware.CanExceedLimit(ctx) && (filter.Limit > tribehistory.PaginationLimit || filter.Limit <= 0) {
+	if cfg.Filter.Limit > 0 {
-		filter.Limit = tribehistory.PaginationLimit
+		cfg.Limit = cfg.Filter.Limit
 	}
-	filter.Sort = utils.SanitizeSortExpression(filter.Sort)
+	if cfg.Filter.Offset > 0 {
-	return ucase.repo.Fetch(ctx, tribehistory.FetchConfig{
+		cfg.Offset = cfg.Filter.Offset
-		Server: server,
+	}
-		Filter: filter,
+	if cfg.Filter.Sort != "" {
-		Count:  true,
+		cfg.Sort = append(cfg.Sort, cfg.Filter.Sort)
-	})
+	}
+	if !middleware.CanExceedLimit(ctx) && (cfg.Limit > tribehistory.PaginationLimit || cfg.Limit <= 0) {
+		cfg.Limit = tribehistory.PaginationLimit
+	}
+	cfg.Sort = utils.SanitizeSortExpressions(cfg.Sort)
+	return ucase.repo.Fetch(ctx, cfg)
 }