type complexity measurement improvement + misc corrections

api.go

@@ -97,6 +97,10 @@ func (s *Sorare) Debug() *Sorare {
 	return s
 }
 
+func (s *Sorare) SetApiKey(apiKey string) {
+	s.Client.SetApiKey(apiKey)
+}
+
 func (s *Sorare) SetJWTToken(token graphql.JwtToken, audience string) {
 	s.Client.SetJWTToken(token, audience)
 }

cmd/console/main.go

@@ -31,39 +31,48 @@ func main() {
 
 	ctx := context.Background()
 
-	si, err := api.ShopItems.Get(ctx, sorare.ShopItemsParams{
-		Types:        []sorare.ShopItemType{sorare.ShopItemTypeLevelUp},
-		UnlockedOnly: true,
-	})
+	p, err := api.Football.Player.Get(ctx, graphql.SlugParams{Slug: "joshua-kimmich"})
 	if err != nil {
 		panic(err)
 	}
-	for _, item := range si {
-		log.Printf(
-			"%s %d %d %s %s",
-			item.TypeName,
-			item.ShopItemInterface.MyBalance,
-			item.ShopItemInterface.Price,
-			item.LevelUpShopItem.Rarity,
-			time.Until(item.ShopItemInterface.MyLimitResetAt).String(),
-		)
-	}
+	log.Printf("%+v", p)
 
-	cu, err := api.Users.CurrentUser.Get(ctx, graphql.EmptyParams{})
-	if err != nil {
-		panic(err)
-	}
-	log.Printf("%d", cu.CoinBalance)
-	// cu, err := api.Users.FootballCards("gigiz22").Get(ctx, football.CardsParams{
+	// si, err := api.ShopItems.Get(ctx, sorare.ShopItemsParams{
+	// 	Types:        []sorare.ShopItemType{sorare.ShopItemTypeLevelUp},
+	// 	UnlockedOnly: true,
+	// })
+	// if err != nil {
+	// 	panic(err)
+	// }
+	// for _, item := range si {
+	// 	log.Printf(
+	// 		"%s %d %d %s %s",
+	// 		item.TypeName,
+	// 		item.ShopItemInterface.MyBalance,
+	// 		item.ShopItemInterface.Price,
+	// 		item.LevelUpShopItem.Rarity,
+	// 		time.Until(item.ShopItemInterface.MyLimitResetAt).String(),
+	// 	)
+	// }
+
+	// cu, err := api.Users.CurrentUser.Get(ctx, graphql.EmptyParams{})
+	// if err != nil {
+	// 	panic(err)
+	// }
+	// log.Printf("%d", cu.CoinBalance)
+	// cards, err := api.Users.FootballCards("gigiz22").Get(ctx, football.CardsParams{
 	// 	Rarities: []types.Rarity{types.RarityLimited},
 	// })
 	// if err != nil {
 	// 	panic(err)
 	// }
-	// sort.Slice(cu, func(i, j int) bool {
-	// 	return cu[i].XpNeededForNextGrade-cu[i].Xp > cu[j].XpNeededForNextGrade-cu[j].Xp
+	// sort.Slice(cards, func(i, j int) bool {
+	// 	return cards[i].XpNeededForNextGrade-cards[i].Xp > cards[j].XpNeededForNextGrade-cards[j].Xp
 	// })
-	// for _, card := range cu {
+	// for _, card := range cards {
+	// 	if !card.InSeasonEligible {
+	// 		continue
+	// 	}
 	// 	log.Printf(
 	// 		"%60s %2d %6d %6d %6d (%d/%d)",
 	// 		card.Token.Name,

football/football.go

@@ -27,6 +27,7 @@ type Football struct {
 	Season             *graphql.Query[Season, SeasonParams]
 
 	So5    *So5
+	Rivals *Rivals
 }
 
 func NewFootball(c *graphql.Client) *Football {
@@ -109,7 +110,7 @@ func NewFootball(c *graphql.Client) *Football {
 			c,
 			"players",
 			[]string{"football"},
-		),
+		).WithMaxPageSize(100),
 		Season: graphql.NewQuery[Season, SeasonParams](
 			c,
 			"season",
@@ -117,5 +118,6 @@ func NewFootball(c *graphql.Client) *Football {
 		),
 
 		So5:    NewSo5(c),
+		Rivals: NewRivals(c),
 	}
 }

football/player.go

@@ -40,6 +40,20 @@ type CardSupply struct {
 	Unique    int `graphql:"unique"`
 }
 
+type MembershipStats struct {
+	Season struct {
+		StartYear int `graphql:"startYear"`
+	} `graphql:"season"`
+	Appearances   int `graphql:"appearances"`
+	Goals         int `graphql:"goals"`
+	Assists       int `graphql:"assists"`
+	YellowCards   int `graphql:"yellowCards"`
+	RedCards      int `graphql:"redCards"`
+	MinutesPlayed int `graphql:"minutesPlayed"`
+	SubstituteIn  int `graphql:"substituteIn"`
+	SubstituteOut int `graphql:"substituteOut"`
+}
+
 type Membership struct {
 	Id             graphql.Id `graphql:"id"`
 	StartDate      time.Time  `graphql:"startDate"`
@@ -53,6 +67,7 @@ type Membership struct {
 			Slug string `graphql:"slug"`
 		} `graphql:"... on NationalTeam"`
 	} `graphql:"membershipTeam"`
+	//Stats []MembershipStats `graphql:"stats"`
 }
 
 type Player struct {

football/rivals.go

@@ -0,0 +1,17 @@
+package football
+
+import "git.lehouerou.net/laurent/sorare/graphql"
+
+type Rivals struct {
+	c *graphql.Client
+
+	PastGames *graphql.PaginatedQuery[RivalsGame, graphql.EmptyParams]
+}
+
+func NewRivals(c *graphql.Client) *Rivals {
+	return &Rivals{
+		c: c,
+
+		PastGames: graphql.NewPaginatedQuery[RivalsGame, graphql.EmptyParams](c, "pastGamesPaginated", []string{"football", "rivals"}).WithOverrideComplexity(107),
+	}
+}

football/rivals_game.go

@@ -0,0 +1,32 @@
+package football
+
+import (
+	"git.lehouerou.net/laurent/sorare/graphql"
+	"git.lehouerou.net/laurent/sorare/types"
+)
+
+type RivalsDraftableObject struct {
+	Id       graphql.Id `graphql:"id"`
+	CapValue float64    `graphql:"capValue"`
+	Player   struct {
+		Slug       string `graphql:"slug"`
+		ActiveClub struct {
+			Slug string `graphql:"slug"`
+		}
+		ActiveNationalTeam struct {
+			Slug string `graphql:"slug"`
+		}
+	} `graphql:"player"`
+	Position types.Position `graphql:"position"`
+}
+
+type RivalsGame struct {
+	Id               graphql.Id              `graphql:"id"`
+	Slug             string                  `graphql:"slug"`
+	Cap              int                     `graphql:"cap"`
+	DraftablePlayers []RivalsDraftableObject `graphql:"draftablePlayers"`
+	FormationKnown   bool                    `graphql:"formationKnown"`
+	Game             struct {
+		Id graphql.Id `graphql:"id"`
+	} `graphql:"game"`
+}

football/so5.go

@@ -22,28 +22,28 @@ func NewSo5(c *graphql.Client) *So5 {
 		So5Fixture: graphql.NewQuery[So5Fixture, So5FixtureParams](
 			c,
 			"so5Fixture",
-			[]string{"football", "so5"},
+			[]string{"so5"},
 		),
 		So5Fixtures: graphql.NewPaginatedQuery[So5Fixture, So5FixturesParams](
 			c,
 			"so5Fixtures",
-			[]string{"football", "so5"},
+			[]string{"so5"},
 		),
 		So5Score: graphql.NewQuery[So5Score, graphql.IdParams](
 			c,
 			"so5Score",
-			[]string{"football", "so5"},
+			[]string{"so5"},
 		),
 		So5Leaderboard: graphql.NewQuery[So5Leaderboard, graphql.SlugParams](
 			c,
 			"so5Leaderboard",
-			[]string{"football", "so5"},
+			[]string{"so5"},
 		),
 
 		UpcomingLeaderboards: graphql.NewQuery[[]So5Leaderboard, UpcomingLeaderboardsParams](
 			c,
 			"upcomingLeaderboards",
-			[]string{"football", "so5"},
+			[]string{"so5"},
 		),
 	}
 }

graphql/authentication.go

@@ -58,9 +58,9 @@ type JwtToken struct {
 type SignIn struct {
 	CurrentUser struct {
 		Slug string
-		JwtToken JwtToken `graphql:"jwtToken(aud: $aud)"`
 	} `graphql:"currentUser"`
 	OtpSessionChallenge string
+	JwtToken            JwtToken `graphql:"jwtToken(aud: $aud)"`
 	Errors              []struct {
 		Message string
 	} `graphql:"errors"`
@@ -116,12 +116,12 @@ func (c *Client) getNewToken(
 	}
 
 	if len(res.Errors) == 0 {
-		if res.CurrentUser.JwtToken.Token == "" {
+		if res.JwtToken.Token == "" {
 			return JwtToken{}, errors.New(
 				"no errors & no jwt token returned on email/password mutation",
 			)
 		}
-		return res.CurrentUser.JwtToken, nil
+		return res.JwtToken, nil
 	}
 
 	if res.Errors[0].Message == "invalid" {
@@ -146,10 +146,10 @@ func (c *Client) getNewToken(
 		}
 
 		if len(resOtp.Errors) == 0 {
-			if resOtp.CurrentUser.JwtToken.Token == "" {
+			if resOtp.JwtToken.Token == "" {
 				return JwtToken{}, errors.New("no errors & no jwt token returned on otp mutation")
 			}
-			return resOtp.CurrentUser.JwtToken, nil
+			return resOtp.JwtToken, nil
 		}
 		return JwtToken{}, errors.Errorf("validating otp: %s", resOtp.Errors[0].Message)
 	}

graphql/client.go

@@ -3,6 +3,7 @@ package graphql
 import (
 	"context"
 	"net/http"
+	"reflect"
 	"sync"
 	"time"
 
@@ -22,9 +23,11 @@ type Client struct {
 	httpClient    *http.Client
 	gql           *graphql.Client
 	rl            *rate.Limiter
+	apirl         *rate.Limiter
 	lock          *sync.Mutex
 	authenticated bool
 	token         JwtToken
+	apiKey        string
 }
 
 func NewClient(httpclient *http.Client, baseUrl string) *Client {
@@ -32,6 +35,7 @@ func NewClient(httpclient *http.Client, baseUrl string) *Client {
 		httpClient:    httpclient,
 		gql:           graphql.NewClient(baseUrl, httpclient),
 		rl:            rate.NewLimiter(rate.Every(rateLimitPeriod), rateLimitBurst),
+		apirl:         rate.NewLimiter(rate.Every(rateLimitPeriod/10), rateLimitBurst*10),
 		lock:          &sync.Mutex{},
 		authenticated: false,
 	}
@@ -50,12 +54,18 @@ func (c *Client) SetJWTToken(token JwtToken, audience string) {
 	c.authenticated = true
 }
 
-func (c *Client) MaxComplexity() int {
-	if c.authenticated {
+func (c *Client) SetApiKey(apiKey string) {
+	c.gql = c.gql.WithRequestModifier(func(request *http.Request) {
+		request.Header.Set("APIKEY", apiKey)
+	})
+	c.apiKey = apiKey
+}
+
+func (c *Client) MaxQueryComplexity() int {
+	if c.apiKey != "" || c.authenticated {
 		return MaxAuthenticatedQueryComplexity
-	} else {
-		return MaxAnonymousQueryComplexity
 	}
+	return MaxAnonymousQueryComplexity
 }
 
 func (c *Client) ConstructRawQuery(
@@ -71,10 +81,17 @@ func (c *Client) Query(
 	variables interface{},
 	options ...graphql.Option,
 ) error {
+	if c.apiKey != "" {
+		err := c.apirl.Wait(ctx)
+		if err != nil {
+			return errors.Wrap(err, "waiting for rate limit")
+		}
+	} else {
 		err := c.rl.Wait(ctx)
 		if err != nil {
 			return errors.Wrap(err, "waiting for rate limit")
 		}
+	}
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	return c.gql.Query(ctx, q, variables, options...)
@@ -86,10 +103,17 @@ func (c *Client) QueryRaw(
 	variables interface{},
 	options ...graphql.Option,
 ) ([]byte, error) {
+	if c.apiKey != "" {
+		err := c.apirl.Wait(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "waiting for rate limit")
+		}
+	} else {
 		err := c.rl.Wait(ctx)
 		if err != nil {
 			return nil, errors.Wrap(err, "waiting for rate limit")
 		}
+	}
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	return c.gql.QueryRaw(ctx, q, variables, options...)
@@ -101,11 +125,67 @@ func (c *Client) Mutate(
 	variables interface{},
 	options ...graphql.Option,
 ) error {
+	if c.apiKey != "" {
+		err := c.apirl.Wait(ctx)
+		if err != nil {
+			return errors.Wrap(err, "waiting for rate limit")
+		}
+	} else {
 		err := c.rl.Wait(ctx)
 		if err != nil {
 			return errors.Wrap(err, "waiting for rate limit")
 		}
+	}
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	return c.gql.Mutate(ctx, q, variables, options...)
 }
+
+func GetTypeComplexity(t reflect.Type) int {
+	var checkStruct func(t reflect.Type, complexity *int)
+	checkStruct = func(t reflect.Type, complexity *int) {
+		if t.Kind() != reflect.Struct {
+			return
+		}
+		for i := 0; i < t.NumField(); i++ {
+			field := t.Field(i)
+			tag := field.Tag.Get("graphql")
+			if field.Type.Kind() == reflect.Struct {
+				*complexity++
+				if len(tag) > 6 && tag[:6] == "... on" {
+					*complexity--
+				}
+				checkStruct(field.Type, complexity)
+				continue
+			}
+			if field.Type.Kind() == reflect.Slice {
+				if isSimpleType(field.Type.Elem()) {
+					*complexity++
+				} else {
+					*complexity++
+					tmpcomplexity := 0
+					checkStruct(field.Type.Elem(), &tmpcomplexity)
+					*complexity += tmpcomplexity * 10
+				}
+				continue
+			}
+			if tag != "" && tag != "__typename" {
+				*complexity++
+			}
+		}
+	}
+	complexity := 0
+	checkStruct(t, &complexity)
+	return complexity
+}
+
+func isSimpleType(t reflect.Type) bool {
+	switch t.Kind() {
+	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
+		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.String:
+		return true
+	default:
+		return false
+	}
+}

graphql/paginated_query.go

@@ -3,8 +3,6 @@ package graphql
 import (
 	"context"
 	"reflect"
-
-	"github.com/rs/zerolog/log"
 )
 
 type PaginatedQuery[ResultType any, Params any] struct {
@@ -14,6 +12,8 @@ type PaginatedQuery[ResultType any, Params any] struct {
 
 	additionalPayloadParams map[string]interface{}
 	additionalQueryParams   map[string]interface{}
+
+	overrideComplexity int
 }
 
 func NewPaginatedQuery[ResultType any, Params any](
@@ -27,6 +27,7 @@ func NewPaginatedQuery[ResultType any, Params any](
 		containerLayers:         containerLayers,
 		additionalPayloadParams: make(map[string]interface{}),
 		additionalQueryParams:   make(map[string]interface{}),
+		overrideComplexity:      0,
 	}
 }
 
@@ -46,6 +47,11 @@ func (pq *PaginatedQuery[ResultType, Params]) WithQueryParam(
 	return pq
 }
 
+func (pq *PaginatedQuery[ResultType, Params]) WithOverrideComplexity(complexity int) *PaginatedQuery[ResultType, Params] {
+	pq.overrideComplexity = complexity
+	return pq
+}
+
 type PaginatedQueryGetOptions struct {
 	Limit int
 }
@@ -70,18 +76,26 @@ func (pq *PaginatedQuery[ResultType, Params]) Get(
 	var res []ResultType
 	after := ""
 	var noop ResultType
-	pageSize := (pq.c.MaxComplexity() - 9) / (GetComplexity(reflect.TypeOf(noop)) + 1)
-	log.Debug().Msgf("using page size %d", pageSize)
+	complexity := pq.overrideComplexity
+	if complexity == 0 {
+		complexity = GetTypeComplexity(reflect.TypeOf(noop))
+	}
+	maxPageSize := (pq.c.MaxQueryComplexity() - 7 - len(pq.containerLayers)) / complexity
 	for {
+		pageSize := maxPageSize
+		if opts.Limit > 0 {
+			remaining := opts.Limit - len(res)
+			if remaining < pageSize {
+				pageSize = remaining
+			}
+		}
 		page, pi, err := pq.getPage(ctx, params, after, pageSize)
 		if err != nil {
 			return nil, err
 		}
-		for _, item := range page {
-			res = append(res, item)
+		res = append(res, page...)
 		if opts.Limit > 0 && len(res) >= opts.Limit {
-				return res, nil
-			}
+			return res[:opts.Limit], nil
 		}
 		if !pi.HasNextPage {
 			break
@@ -125,35 +139,3 @@ func (pq *PaginatedQuery[ResultType, Params]) getPage(
 	}
 	return res.Nodes, res.PageInfo, nil
 }
-
-func GetComplexity(t reflect.Type) int {
-	var checkStruct func(t reflect.Type, complexity *int)
-	checkStruct = func(t reflect.Type, complexity *int) {
-		if t.Kind() != reflect.Struct {
-			return
-		}
-		for i := 0; i < t.NumField(); i++ {
-			field := t.Field(i)
-			if field.Type.Kind() == reflect.Struct {
-				*complexity++
-				tag := field.Tag.Get("graphql")
-				if len(tag) > 6 && tag[:6] == "... on" {
-					*complexity--
-				}
-				checkStruct(field.Type, complexity)
-				continue
-			}
-			if field.Type.Kind() == reflect.Slice {
-				*complexity++
-				tmpcomplexity := 0
-				checkStruct(field.Type.Elem(), &tmpcomplexity)
-				*complexity += tmpcomplexity * 10
-				continue
-			}
-			*complexity++
-		}
-	}
-	complexity := 0
-	checkStruct(t, &complexity)
-	return complexity
-}

graphql/query.go

@@ -3,6 +3,7 @@ package graphql
 import (
 	"context"
 	"fmt"
+	"reflect"
 	"strings"
 
 	"github.com/pkg/errors"
@@ -15,6 +16,8 @@ type Query[ReturnType any, Params any] struct {
 
 	additionalPayloadParams map[string]interface{}
 	additionalQueryParams   map[string]interface{}
+
+	maxPageSize int
 }
 
 func NewQuery[ReturnType any, Params any](
@@ -29,6 +32,7 @@ func NewQuery[ReturnType any, Params any](
 
 		additionalPayloadParams: make(map[string]interface{}),
 		additionalQueryParams:   make(map[string]interface{}),
+		maxPageSize:             0,
 	}
 }
 
@@ -48,6 +52,27 @@ func (r *Query[ReturnType, Params]) WithQueryParam(
 	return r
 }
 
+func (r *Query[ReturnType, Params]) WithMaxPageSize(maxPageSize int) *Query[ReturnType, Params] {
+	r.maxPageSize = maxPageSize
+	return r
+}
+
+func (r *Query[ReturnType, Params]) GetPageSize() int {
+	t := reflect.TypeOf((*ReturnType)(nil)).Elem()
+	if t.Kind() == reflect.Slice {
+		t = t.Elem()
+	}
+	complexity := GetTypeComplexity(t)
+	maxComplexity := r.c.MaxQueryComplexity()
+	layers := len(r.containerLayers)
+	computedPageSize := (maxComplexity - layers - 1) / complexity
+
+	if r.maxPageSize > 0 && r.maxPageSize < computedPageSize {
+		return r.maxPageSize
+	}
+	return computedPageSize
+}
+
 func (r *Query[ReturnType, Params]) Get(ctx context.Context, params Params) (ReturnType, error) {
 
 	paramsMap := convertParamsToMap(params)

user.go

@@ -13,7 +13,7 @@ import (
 
 type baseUser struct {
 	Active             bool `graphql:"active"`
-	CardCounts struct {
+	FootballCardCounts struct {
 		Common       int `graphql:"common"`
 		CustomSeries int `graphql:"customSeries"`
 		Limited      int `graphql:"limited"`
@@ -21,7 +21,7 @@ type baseUser struct {
 		SuperRare    int `graphql:"superRare"`
 		Unique       int `graphql:"unique"`
 		Total        int `graphql:"total"`
-	} `graphql:"cardCounts"`
+	} `graphql:"footballCardCounts"`
 	CreatedAt       time.Time  `graphql:"createdAt"`
 	EthVaultId      int        `graphql:"ethVaultId"`
 	EthereumAddress string     `graphql:"ethereumAddress"`